@lppedd/di-wise-neo 0.3.0

package/src/tokensRef.ts

@@ -0,0 +1,46 @@
+import { assert } from "./errors";
+import type { Token, Tokens } from "./token";
+
+export interface TokensRef<Value = any> {
+  readonly getRefTokens: () => Set<Token<Value>>;
+}
+
+export interface TokenRef<Value = any> {
+  readonly getRefToken: () => Token<Value>;
+}
+
+/**
+ * Allows referencing a token that is declared later in the file by wrapping it in a function.
+ */
+export function forwardRef<Value>(token: () => Tokens<Value>): TokensRef<Value>;
+export function forwardRef<Value>(token: () => Token<Value>): TokenRef<Value>;
+export function forwardRef<Value>(
+  token: () => Token<Value> | Tokens<Value>,
+): TokensRef<Value> & TokenRef<Value> {
+  return {
+    getRefTokens: (): Set<Token<Value>> => {
+      // Normalize the single token here, so that we don't have
+      // to do it at every getRefTokens call site
+      const tokenOrTokens = token();
+      const tokensArray = Array.isArray(tokenOrTokens) ? tokenOrTokens : [tokenOrTokens];
+      return new Set(tokensArray);
+    },
+    getRefToken: () => {
+      const tokenOrTokens = token();
+      assert(!Array.isArray(tokenOrTokens), "internal error: ref tokens should be a single token");
+      return tokenOrTokens;
+    },
+  };
+}
+
+// @internal
+export function isTokensRef(value: any): value is TokensRef {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return value && typeof value === "object" && typeof value.getRefTokens === "function";
+}
+
+// @internal
+export function isTokenRef(value: any): value is TokenRef {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return value && typeof value === "object" && typeof value.getRefToken === "function";
+}

package/src/utils/context.ts

@@ -0,0 +1,19 @@
+// @internal
+export function createInjectionContext<T extends {}>(): readonly [
+  (next: T) => () => T | null,
+  () => T | null,
+] {
+  let current: T | null = null;
+
+  function provide(next: T): () => T | null {
+    const prev = current;
+    current = next;
+    return () => (current = prev);
+  }
+
+  function use(): T | null {
+    return current;
+  }
+
+  return [provide, use] as const;
+}

package/src/utils/disposable.ts

@@ -0,0 +1,10 @@
+// @internal
+export interface Disposable {
+  dispose(): void;
+}
+
+// @internal
+export function isDisposable(value: any): value is Disposable {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return value && typeof value === "object" && typeof value.dispose === "function";
+}

package/src/utils/invariant.ts

@@ -0,0 +1,6 @@
+// @internal
+export function invariant(condition: unknown): asserts condition {
+  if (!condition) {
+    throw new Error("invariant violation");
+  }
+}

package/src/utils/keyedStack.ts

@@ -0,0 +1,26 @@
+import { invariant } from "./invariant";
+
+// @internal
+export class KeyedStack<K extends object, V> {
+  private readonly myEntries = new Array<{ key: K; value: V }>();
+  private readonly myKeys = new WeakSet<K>();
+
+  has(key: K): boolean {
+    return this.myKeys.has(key);
+  }
+
+  peek(): V | undefined {
+    const entry = this.myEntries.at(-1);
+    return entry?.value;
+  }
+
+  push(key: K, value: V): () => void {
+    invariant(!this.has(key));
+    this.myKeys.add(key);
+    this.myEntries.push({ key, value });
+    return () => {
+      this.myEntries.pop();
+      this.myKeys.delete(key);
+    };
+  }
+}

package/src/utils/typeName.ts

@@ -0,0 +1,28 @@
+// @internal
+export function getTypeName(value: unknown): string {
+  if (typeof value == "string") {
+    return `"${value}"`;
+  }
+
+  if (typeof value == "function") {
+    return (value.name && `typeof ${value.name}`) || "Function";
+  }
+
+  if (typeof value == "object") {
+    if (value === null) {
+      return "null";
+    }
+
+    const proto: object | null = Object.getPrototypeOf(value);
+
+    if (proto && proto !== Object.prototype) {
+      const constructor: unknown = proto.constructor;
+
+      if (typeof constructor == "function" && constructor.name) {
+        return constructor.name;
+      }
+    }
+  }
+
+  return typeof value;
+}

package/src/utils/weakRefMap.ts

@@ -0,0 +1,28 @@
+import { invariant } from "./invariant";
+
+// @internal
+export class WeakRefMap<K extends WeakKey, V extends object> {
+  private readonly myMap = new WeakMap<K, WeakRef<V>>();
+
+  get(key: K): V | undefined {
+    const ref = this.myMap.get(key);
+
+    if (ref) {
+      const value = ref.deref();
+
+      if (value) {
+        return value;
+      }
+
+      this.myMap.delete(key);
+    }
+  }
+
+  set(key: K, value: V): () => void {
+    invariant(!this.get(key));
+    this.myMap.set(key, new WeakRef(value));
+    return () => {
+      this.myMap.delete(key);
+    };
+  }
+}

package/src/valueRef.ts

@@ -0,0 +1,3 @@
+export interface ValueRef<T = any> {
+  readonly current: T;
+}