reverse initialization order, prepare for publishing

.npmignore

-test
-js
-node_modules

package.json

 {
   "name": "dependjs",
   "version": "0.0.1",
-  "description": "dependjs is a javascript dependency injector",
+  "description": "dependjs is a typescript dependency injector",
   "main": "./js/Index.js",
   "repository": {
     "type": "git",
   },
   "homepage": "https://gitea.nitowa.xyz/docs/dependjs",
   "keywords": [
+    "typescript",
     "dependency injection",
     "inversion of control"
   ],
     "mocha": "^6.2.0"
   },
   "files": [
-    "js"
+    "js/Index.js",
+    "js/Index.d.ts",
+    "js/src/*"
   ]
 }

src/Decorator.ts

   interface?: Constructor<any>,
   initializationPriority?: number
 }): GenericClassDecorator<Type<any>> {
+
   return (clazz: Type<any>) => {
     Injector['singletonDefinitions'].push({
       initializationPriority: config ?. initializationPriority,

src/Injector.ts

 import 'reflect-metadata';
 import { ERR_NO_INITIALIZE_WITH_PRIORITY, ERR_NO_INJECTION_TOKEN } from './Strings';
-import { Constructor, Type, Module as SingletonDefinition, InjectionError, InjectionResolutionError } from './Internals';
+import { Constructor, Type, SingletonDefinition, InjectionError, InjectionResolutionError } from './Internals';
 
 class _Injector {
 
 
   private initializeSingletons = () => {
     this.singletonDefinitions
-      .sort((a, b) => (a.initializationPriority ?? 0) - (b.initializationPriority ?? 0))
+      .sort((a, b) => (b.initializationPriority ?? 0) - (a.initializationPriority ?? 0))
       .map(def => this.singletonObjects[def.ctor.name])
       .forEach(obj => obj.initialize ? obj.initialize() : undefined)
   }

src/Internals.ts

  */
 export type GenericClassDecorator<T> = (target: T) => void;
 
-export type Module = {
-  initializationPriority?: number //Priority of initializing this object after creation 
+export type SingletonDefinition = {
+  initializationPriority?: number //Priority of initializing this object after creation, lower value means higher priority; default: 0
   ctor: Type<any>                 //Object constructor to make singleton from
 }
 

test/BasicTest/ComponentB.ts

 }
 
 @Singleton({
-    interface: IComponentB
+    interface: IComponentB,
 })
 export class ComponentB implements IComponentB, Initializable{
 

test/BasicTest/ComponentC.ts

 import { Inject, Singleton } from "../../src/Decorator"
-import { Initializable } from "../../src/Interfaces"
-import { COMPONENT_B_VALUE, COMPONENT_C_VALUE } from "../CONSTANTS"
+import { COMPONENT_C_VALUE } from "../CONSTANTS"
 import { ComponentA } from "./ComponentA"
 
+export class benis{
+
+}
+
 export abstract class IComponentC{
     getFromA: () => string
     getFromThis: () => string
 @Singleton({
     interface: IComponentC,
 })
-export class ComponentC implements IComponentC{
+export class ComponentC{
 
     @Inject(ComponentA)
     private componentA: ComponentA

test/BasicTest/Test.ts

 
 chai.use(chaiAsPromised);
 
-describe('dependjs', () => {
+describe('BasicTest', () => {
     it('is able to resolve linear dependencies', () => {
 
         const testComp = Injector.resolve(TestComponent)

test/BasicTest/TestComponent.ts

 import { Inject, Singleton } from "../../src/Decorator";
-import { Initializable } from "../../src/Interfaces";
 import {ComponentA} from "./ComponentA"
 import {IComponentB} from "./ComponentB"
 import { ComponentC } from "./ComponentC";

test/InitializationTest/Test.ts

 
 chai.use(chaiAsPromised);
 
-describe('dependjs', () => {
+describe('InitializationTest', () => {
     it('initialized in the requested order', () => {
 
         const testComp = Injector.resolve(TestComponent)
         const data = testComp.getData()
 
-        expect(data).to.eql([COMPONENT_C_VALUE, COMPONENT_B_VALUE, COMPONENT_A_VALUE])
+        expect(data).to.eql([COMPONENT_A_VALUE, COMPONENT_B_VALUE, COMPONENT_C_VALUE])
     })
 })