@tstdl/base 0.85.16 → 0.85.18

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.18",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/rxjs/index.d.ts

@@ -7,6 +7,7 @@ export * from './performance-observer.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';
+export * from './start-with-provider.js';
 export * from './teardown.js';
 export * from './timing.js';
 export * from './touch.js';

package/rxjs/index.js

@@ -24,6 +24,7 @@ __reExport(rxjs_exports, require("./performance-observer.js"), module.exports);
 __reExport(rxjs_exports, require("./resize-observer.js"), module.exports);
 __reExport(rxjs_exports, require("./retry-backoff.js"), module.exports);
 __reExport(rxjs_exports, require("./slow-array.js"), module.exports);
+__reExport(rxjs_exports, require("./start-with-provider.js"), module.exports);
 __reExport(rxjs_exports, require("./teardown.js"), module.exports);
 __reExport(rxjs_exports, require("./timing.js"), module.exports);
 __reExport(rxjs_exports, require("./touch.js"), module.exports);

package/rxjs/start-with-provider.d.ts

@@ -0,0 +1,2 @@
+import type { OperatorFunction } from 'rxjs';
+export declare function startWithProvider<T, D>(valueProvider: () => D): OperatorFunction<T, T | D>;

package/rxjs/start-with-provider.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var start_with_provider_exports = {};
+__export(start_with_provider_exports, {
+  startWithProvider: () => startWithProvider
+});
+module.exports = __toCommonJS(start_with_provider_exports);
+var import_rxjs = require("rxjs");
+function startWithProvider(valueProvider) {
+  return function startWithProvider2(source) {
+    return (0, import_rxjs.concat)((0, import_rxjs.defer)(() => (0, import_rxjs.of)(valueProvider())), source);
+  };
+}

package/signals/api.d.ts

@@ -1,5 +1,5 @@
 import type * as Types from './implementation/index.js';
-export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, WritableSignal } from './implementation/index.js';
+export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, ToSignalOptions, WritableSignal } from './implementation/index.js';
 export type SignalsConfiguration = {
     signal: typeof Types.signal;
     computed: typeof Types.computed;

package/signals/api.js

@@ -28,13 +28,13 @@ __export(api_exports, {
   untracked: () => untracked
 });
 module.exports = __toCommonJS(api_exports);
-let signal;
-let computed;
-let effect;
-let untracked;
-let isSignal;
-let toSignal;
-let toObservable;
+let signal = throwSignalsNotConfigured;
+let computed = throwSignalsNotConfigured;
+let effect = throwSignalsNotConfigured;
+let untracked = throwSignalsNotConfigured;
+let isSignal = throwSignalsNotConfigured;
+let toSignal = throwSignalsNotConfigured;
+let toObservable = throwSignalsNotConfigured;
 function configureSignals(configuration) {
   signal = configuration.signal;
   computed = configuration.computed;
@@ -44,3 +44,6 @@ function configureSignals(configuration) {
   toSignal = configuration.toSignal;
   toObservable = configuration.toObservable;
 }
+function throwSignalsNotConfigured() {
+  throw new Error("Signals are not configured. Use configureDefaultSignalsImplementation() for default implementation or configureSignals() for custom implementation.");
+}

package/signals/implementation/graph.js

@@ -71,7 +71,7 @@ class ReactiveNode {
   consumerPollProducersForChange() {
     for (const [producerId, edge] of this.producers) {
       const producer = edge.producerNode.deref();
-      if (producer === void 0 || edge.atTrackingVersion !== this.trackingVersion) {
+      if (producer == null || edge.atTrackingVersion !== this.trackingVersion) {
         this.producers.delete(producerId);
         producer?.consumers.delete(this.id);
         continue;
@@ -91,7 +91,7 @@ class ReactiveNode {
     try {
       for (const [consumerId, edge] of this.consumers) {
         const consumer = edge.consumerNode.deref();
-        if (consumer === void 0 || consumer.trackingVersion !== edge.atTrackingVersion) {
+        if (consumer == null || consumer.trackingVersion !== edge.atTrackingVersion) {
           this.consumers.delete(consumerId);
           consumer?.producers.delete(this.id);
           continue;

package/signals/index.d.ts

@@ -3,5 +3,6 @@ export * from './computed-with-dependencies.js';
 export * from './effect-with-dependencies.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -20,5 +20,6 @@ __reExport(signals_exports, require("./computed-with-dependencies.js"), module.e
 __reExport(signals_exports, require("./effect-with-dependencies.js"), module.exports);
 __reExport(signals_exports, require("./pipe.js"), module.exports);
 __reExport(signals_exports, require("./switch-map.js"), module.exports);
+__reExport(signals_exports, require("./to-signal-2.js"), module.exports);
 __reExport(signals_exports, require("./types.js"), module.exports);
 __reExport(signals_exports, require("./untracked-operator.js"), module.exports);

package/signals/pipe.d.ts

@@ -16,7 +16,7 @@ export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1:
 export declare function pipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
 export declare function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
 /**
- * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the {@link startWith} operator, otherwise an error is thrown.
+ * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the `startWith` operator, otherwise an error is thrown.
  */
 export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
 export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;

package/signals/pipe.js

@@ -23,11 +23,13 @@ __export(pipe_exports, {
 });
 module.exports = __toCommonJS(pipe_exports);
 var import_rxjs = require("rxjs");
+var import_start_with_provider = require("../rxjs/start-with-provider.js");
 var import_api = require("./api.js");
+var import_to_signal_2 = require("./to-signal-2.js");
 function pipe(source, ...operators) {
-  return rawPipe(source, (0, import_rxjs.startWith)(source()), (0, import_rxjs.distinctUntilChanged)(), ...operators);
+  return rawPipe(source, (0, import_start_with_provider.startWithProvider)(source), (0, import_rxjs.distinctUntilChanged)(), ...operators);
 }
 function rawPipe(source, ...operators) {
   const piped = (0, import_api.toObservable)(source).pipe(...operators);
-  return (0, import_api.toSignal)(piped, { requireSync: true });
+  return (0, import_to_signal_2.toSignal2)(piped, { requireSync: true });
 }

package/signals/to-signal-2.d.ts

@@ -0,0 +1,14 @@
+import type { Subscribable } from 'rxjs';
+import type { Signal, ToSignalOptions } from './api.js';
+export type ToSignal2Options<T> = ToSignalOptions<T> & {
+    /** defer subscription until signal is used */
+    lazy?: boolean;
+};
+/** like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily */
+export declare function toSignal2<T>(source: Subscribable<T>): Signal<T | undefined>;
+export declare function toSignal2<T>(source: Subscribable<T>, options: ToSignal2Options<undefined> & {
+    requireSync: true;
+}): Signal<T>;
+export declare function toSignal2<T, const I = undefined>(source: Subscribable<T>, options: ToSignal2Options<I> & {
+    requireSync?: false;
+}): Signal<T | I>;

package/signals/to-signal-2.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var to_signal_2_exports = {};
+__export(to_signal_2_exports, {
+  toSignal2: () => toSignal2
+});
+module.exports = __toCommonJS(to_signal_2_exports);
+var import_core = require("../core.js");
+var import_finalization = require("../memory/finalization.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_api = require("./api.js");
+var StateKind;
+(function(StateKind2) {
+  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
+  StateKind2[StateKind2["Value"] = 1] = "Value";
+  StateKind2[StateKind2["Error"] = 2] = "Error";
+})(StateKind || (StateKind = {}));
+function toSignal2(source, options) {
+  const initialState = options?.requireSync == true ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: options?.initialValue };
+  const state = (0, import_api.signal)(initialState);
+  let subscription;
+  if (options?.lazy != true) {
+    subscription = subscribe(source, state, options);
+  }
+  const result = (0, import_api.computed)(() => {
+    if ((0, import_type_guards.isUndefined)(subscription)) {
+      subscription = subscribe(source, state, options);
+    }
+    const current = state();
+    switch (current.kind) {
+      case StateKind.Value:
+        return current.value;
+      case StateKind.Error:
+        throw current.error;
+      case StateKind.NoValue:
+        throw new Error("`toSignalLazy()` called with `requireSync` but `Observable` did not emit synchronously.");
+    }
+  });
+  (0, import_finalization.registerFinalization)(result, () => subscription?.unsubscribe());
+  return result;
+}
+function subscribe(source, state, options) {
+  const subscription = source.subscribe({
+    next: (value) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Value, value })),
+    error: (error) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Error, error }))
+  });
+  if ((0, import_core.isDevMode)() && options?.requireSync == true && (0, import_api.untracked)(state).kind == StateKind.NoValue) {
+    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
+  }
+  return subscription;
+}