@tstdl/base 0.85.16 → 0.85.17

package/data-structures/set-collection.d.ts

@@ -1,5 +1,5 @@
-import { Collection } from './collection.js';
-export declare class SetCollection<T> extends Collection<T, SetCollection<T>> implements globalThis.Set<T> {
+import { DistinctCollection } from './distinct-collection.js';
+export declare class SetCollection<T> extends DistinctCollection<T, SetCollection<T>> implements globalThis.Set<T> {
     private readonly backingSet;
     readonly [Symbol.toStringTag]: string;
     constructor(items?: Iterable<T>);

package/data-structures/set-collection.js

@@ -21,8 +21,8 @@ __export(set_collection_exports, {
   SetCollection: () => SetCollection
 });
 module.exports = __toCommonJS(set_collection_exports);
-var import_collection = require("./collection.js");
-class SetCollection extends import_collection.Collection {
+var import_distinct_collection = require("./distinct-collection.js");
+class SetCollection extends import_distinct_collection.DistinctCollection {
   backingSet;
   [Symbol.toStringTag] = "Set";
   constructor(items) {

package/injector/decorators.d.ts

@@ -1,10 +1,15 @@
 import type { Decorator } from '../reflection/index.js';
-import type { Constructor, Simplify, TypedOmit } from '../types.js';
+import type { Constructor, OneOrMany, Simplify, TypedOmit } from '../types.js';
+import type { Provider } from './provider.js';
 import type { InjectionToken } from './token.js';
-import type { InjectableMetadata } from './type-info.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
-type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
-export type InjectableOptions<T, A> = InjectableMetadata<T, A>;
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A> = RegistrationOptions<T, A> & {
+    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A>;
+};
 export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
 /**
  * Helper decorator to replace a class definition with an other
@@ -13,7 +18,7 @@ export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<Injecta
  */
 export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
 /**
- * registers the class in the global container. Decorated class is not modified in any way
+ * Globally registers the class for injection
  * @param options registration options
  */
 export declare function Injectable<T = any, A = any>(options?: InjectableOptions<T, A>): ClassDecorator;

package/injector/decorators.js

@@ -41,16 +41,16 @@ function ReplaceClass(constructor) {
 }
 function Injectable(options = {}) {
   return (0, import_reflection.createClassDecorator)({
-    data: { [import_symbols.injectableMetadataSymbol]: options },
+    data: { [import_symbols.injectableMetadataSymbol]: {} },
     mergeData: true,
     handler: (data) => {
       const { alias: aliases, provider, ...registrationOptions } = options;
       const token = data.constructor;
       const targetProvider = provider ?? { useClass: token };
-      import_injector.Injector.registerGlobal(token, targetProvider, registrationOptions);
+      import_injector.Injector.register(token, targetProvider, registrationOptions);
       if ((0, import_type_guards.isDefined)(aliases)) {
         for (const alias of (0, import_array.toArray)(aliases)) {
-          import_injector.Injector.registerGlobal(alias, { useToken: token }, registrationOptions);
+          import_injector.Injector.register(alias, { useToken: token }, registrationOptions);
         }
       }
     }

package/injector/injector.d.ts

@@ -43,19 +43,19 @@ export declare class Injector {
     readonly name: string;
     constructor(name: string, parent?: Injector | null);
     /**
-     * Register a provider for a token
+     * Globally register a provider for a token
      * @param token token to register
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerGlobal<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
+    static register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
     /**
-     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerGlobalSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
+    static registerSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
     fork(name: string): Injector;
     /**
      * Register a provider for a token

package/injector/injector.js

@@ -48,12 +48,12 @@ class Injector {
     this.register(Injector, { useValue: this });
   }
   /**
-   * Register a provider for a token
+   * Globally register a provider for a token
    * @param token token to register
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  static registerGlobal(token, provider, options = {}) {
+  static register(token, provider, options = {}) {
     const registration = {
       token,
       provider,
@@ -62,13 +62,13 @@ class Injector {
     addRegistration(Injector.#globalRegistrations, registration);
   }
   /**
-   * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+   * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
    * @param token token to register
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  static registerGlobalSingleton(token, provider, options) {
-    Injector.registerGlobal(token, provider, { ...options, lifecycle: "singleton" });
+  static registerSingleton(token, provider, options) {
+    Injector.register(token, provider, { ...options, lifecycle: "singleton" });
   }
   fork(name) {
     return new Injector(name, this);

package/injector/type-info.d.ts

@@ -1,13 +1,5 @@
-import type { OneOrMany } from '../types.js';
-import type { Provider } from './provider.js';
 import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
-export type InjectableMetadata<T, A> = RegistrationOptions<T, A> & {
-    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
-    alias?: OneOrMany<InjectionToken>;
-    /** custom provider. Useful for example if initialization is required */
-    provider?: Provider<T, A>;
-};
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
 export type InjectMetadata = {
     /** token overwrite by inject decorator */
     injectToken?: InjectionToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.16",
+  "version": "0.85.17",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"