@rhombus-std/di.core 0.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,299 @@
+// src/errors.ts
+class DiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
+
+class OpenTokenRegistrationError extends DiError {
+  token;
+  method;
+  constructor(token, method) {
+    super(method === "add" ? `Cannot register open template "${token}": every type argument of ` + `an open service token must be a hole ($N). Make every argument ` + `a hole, or close the token fully.` : `Cannot register open template "${token}" with ${method}(): open ` + `registrations are class-only. Register a class with ` + `add("${token}", MyClass), or close the token first.`);
+    this.token = token;
+    this.method = method;
+  }
+}
+
+// src/guards.ts
+function isFactoryRef(slot) {
+  return typeof slot === "object" && slot !== null && typeof slot.type === "string";
+}
+function isUnionSlot(slot) {
+  return typeof slot === "object" && slot !== null && Array.isArray(slot.union);
+}
+function isLiteralRef(slot) {
+  return typeof slot === "object" && slot !== null && "value" in slot;
+}
+function isTypeArgRef(slot) {
+  return typeof slot === "object" && slot !== null && typeof slot.typeArg === "number";
+}
+
+// src/tokens.ts
+var HOLE_PATTERN = /^\$[1-9][0-9]*$/;
+function closeToken(base, ...args) {
+  if (!args.length) {
+    return base;
+  }
+  return `${base}<${args.join(",")}>`;
+}
+function parseToken(token) {
+  const open = token.indexOf("<");
+  if (open <= 0) {
+    return;
+  }
+  const base = token.slice(0, open);
+  if (base.includes(">") || base.includes('"')) {
+    return;
+  }
+  const args = [];
+  let depth = 1;
+  let inQuote = false;
+  let argStart = open + 1;
+  for (let i = open + 1;i < token.length; i++) {
+    const ch = token[i];
+    if (inQuote) {
+      if (ch === "\\") {
+        i++;
+      } else if (ch === '"') {
+        inQuote = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inQuote = true;
+    } else if (ch === "<") {
+      depth++;
+    } else if (ch === ">") {
+      depth--;
+      if (!depth) {
+        if (i !== token.length - 1) {
+          return;
+        }
+        const last = token.slice(argStart, i);
+        if (!last) {
+          return;
+        }
+        args.push(last);
+        return { base, args };
+      }
+    } else if (ch === "," && depth === 1) {
+      const arg = token.slice(argStart, i);
+      if (!arg) {
+        return;
+      }
+      args.push(arg);
+      argStart = i + 1;
+    }
+  }
+  return;
+}
+function isOpenToken(token) {
+  if (HOLE_PATTERN.test(token)) {
+    return true;
+  }
+  const parsed = parseToken(token);
+  if (!parsed) {
+    return false;
+  }
+  return parsed.args.some(isOpenToken);
+}
+function substituteToken(template, args) {
+  if (HOLE_PATTERN.test(template)) {
+    return holeArg(Number(template.slice(1)), args);
+  }
+  const parsed = parseToken(template);
+  if (!parsed) {
+    return template;
+  }
+  return closeToken(parsed.base, ...parsed.args.map((a) => substituteToken(a, args)));
+}
+function substituteSignatures(signatures, args) {
+  return signatures.map((sig) => sig.map((slot) => substituteSlot(slot, args)));
+}
+function substituteSlot(slot, args) {
+  if (typeof slot === "string") {
+    return substituteToken(slot, args);
+  }
+  if (isTypeArgRef(slot)) {
+    return { value: holeArg(slot.typeArg, args) };
+  }
+  if (isFactoryRef(slot)) {
+    const type = substituteToken(slot.type, args);
+    if (slot.params) {
+      return { type, params: slot.params.map((p) => substituteToken(p, args)) };
+    }
+    return { type };
+  }
+  if (isUnionSlot(slot)) {
+    return { union: slot.union.map((m) => substituteSlot(m, args)) };
+  }
+  return slot;
+}
+function holeArg(n, args) {
+  const arg = args[n - 1];
+  if (arg === undefined) {
+    throw new RangeError(`Hole $${n} has no matching type argument (${args.length} supplied).`);
+  }
+  return arg;
+}
+
+// src/service-manifest.ts
+function appendTo(map, key, value) {
+  const existing = map.get(key);
+  if (existing === undefined) {
+    map.set(key, [value]);
+  } else {
+    existing.push(value);
+  }
+}
+
+class ServiceManifestClass {
+  #registrations = new Map;
+  #openRegistrations = new Map;
+  constructor() {}
+  #append(token, registration) {
+    appendTo(this.#registrations, token, registration);
+  }
+  #appendOpen(base, registration) {
+    appendTo(this.#openRegistrations, base, registration);
+  }
+  #scopedContinuation(applyScope) {
+    return {
+      as(scope) {
+        if (scope === undefined) {
+          return;
+        }
+        applyScope(scope);
+      }
+    };
+  }
+  #appendScoped(token, base) {
+    this.#append(token, base);
+    const list = this.#registrations.get(token);
+    const index = list.length - 1;
+    return this.#scopedContinuation((scope) => {
+      list[index] = { ...base, scope };
+    });
+  }
+  #appendOpenScoped(token, ctor, signatures) {
+    const parsed = parseToken(token);
+    if (parsed === undefined || !parsed.args.every((arg) => HOLE_PATTERN.test(arg))) {
+      throw new OpenTokenRegistrationError(token, "add");
+    }
+    const base = {
+      template: token,
+      base: parsed.base,
+      pattern: parsed.args,
+      ctor,
+      scope: undefined,
+      signatures
+    };
+    this.#appendOpen(parsed.base, base);
+    const list = this.#openRegistrations.get(parsed.base);
+    const index = list.length - 1;
+    return this.#scopedContinuation((scope) => {
+      list[index] = { ...base, scope };
+    });
+  }
+  add(...args) {
+    if (args.length === 1 || typeof args[0] !== "string") {
+      throw new TypeError("add<I>(ctor) / add<I>(factory) require the @rhombus-std/di.transformer plugin. " + 'Without it, register with an explicit token: add("my:token", MyClass) ' + 'or addFactory("my:token", (scope) => ...).');
+    }
+    const [token, ctor, signatures] = args;
+    if (isOpenToken(token)) {
+      return this.#appendOpenScoped(token, ctor, signatures);
+    }
+    const construct = ctor;
+    return this.#appendScoped(token, {
+      produce: (...a) => new construct(...a),
+      scope: undefined,
+      signatures,
+      name: construct.name,
+      arity: construct.length
+    });
+  }
+  addFactory(...args) {
+    if (args.length === 1 || typeof args[0] !== "string") {
+      throw new TypeError("addFactory<I>(fn) requires the @rhombus-std/di.transformer plugin. Without it, " + 'register with an explicit token: addFactory("my:token", (scope) => ...).');
+    }
+    const [token, factory, signatures] = args;
+    if (isOpenToken(token)) {
+      throw new OpenTokenRegistrationError(token, "addFactory");
+    }
+    return this.#appendScoped(token, {
+      produce: factory,
+      scope: undefined,
+      signatures,
+      name: factory.name,
+      arity: 0
+    });
+  }
+  addValue(...args) {
+    if (args.length === 1 || typeof args[0] !== "string") {
+      throw new TypeError("addValue<I>(value) requires the @rhombus-std/di.transformer plugin. Without it, " + 'register with an explicit token: addValue("my:token", value).');
+    }
+    const [token, value] = args;
+    if (isOpenToken(token)) {
+      throw new OpenTokenRegistrationError(token, "addValue");
+    }
+    this.#append(token, {
+      produce: () => value,
+      scope: undefined,
+      name: "",
+      arity: 0
+    });
+  }
+  seal() {
+    const registrations = new Map;
+    for (const [token, list] of this.#registrations) {
+      registrations.set(token, Object.freeze([...list]));
+    }
+    Object.freeze(registrations);
+    const openRegistrations = new Map;
+    for (const [base, list] of this.#openRegistrations) {
+      openRegistrations.set(base, Object.freeze([...list]));
+    }
+    Object.freeze(openRegistrations);
+    return { registrations, openRegistrations };
+  }
+  build() {
+    throw new TypeError("ServiceManifest.build() requires the @rhombus-std/di runtime. Import " + "@rhombus-std/di (which constructs the resolution engine) before " + "calling build() — di.core ships only the registration collection.");
+  }
+}
+// src/slots.ts
+function union(...slots) {
+  return { union: slots };
+}
+function typeArg(n) {
+  return { typeArg: n };
+}
+// src/provider-token.ts
+var RESOLVER_TOKEN = "@rhombus-std/di.core:Resolver";
+var RESOLVE_SCOPE_TOKEN = "@rhombus-std/di.core:ResolveScope";
+var PROVIDER_TOKENS = new Set([
+  RESOLVER_TOKEN,
+  RESOLVE_SCOPE_TOKEN
+]);
+function isProviderToken(token) {
+  return PROVIDER_TOKENS.has(token);
+}
+export {
+  union,
+  typeArg,
+  substituteToken,
+  substituteSignatures,
+  parseToken,
+  isUnionSlot,
+  isTypeArgRef,
+  isProviderToken,
+  isOpenToken,
+  isLiteralRef,
+  isFactoryRef,
+  closeToken,
+  ServiceManifestClass,
+  RESOLVER_TOKEN,
+  OpenTokenRegistrationError,
+  DiError
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@rhombus-std/di.core",
+  "version": "0.0.0-alpha.0",
+  "description": "The ioc abstractions substrate: the dependency-signature data format, the slot/token surface + helpers, and the concrete registration builder (ServiceManifest) a library author depends on to author registrations without the di resolution engine. Zero dependencies.",
+  "keywords": [
+    "dependency-injection",
+    "di",
+    "ioc",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fnioc/std.git",
+    "directory": "libraries/di.core"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@rhombus-toolkit/func": "3.5.3"
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "lint": "eslint ."
+  }
+}