@djodjonx/neosyringe-core 0.1.0

package/dist/generator/index.d.cts

@@ -0,0 +1,69 @@
+import { t as DependencyGraph } from "../types-DeLOEpiR.cjs";
+
+//#region src/generator/Generator.d.ts
+/**
+ * Generates TypeScript code for the dependency injection container.
+ *
+ * Takes a validated dependency graph and produces:
+ * - Import statements for all dependencies
+ * - Factory functions for each service
+ * - A NeoContainer class with resolve logic
+ */
+declare class Generator {
+  private graph;
+  private useDirectSymbolNames;
+  /**
+       * Creates a new Generator.
+       * @param graph - The validated dependency graph to generate code from.
+       * @param useDirectSymbolNames - If true, uses symbol names directly without import prefixes.
+       */
+  constructor(graph: DependencyGraph, useDirectSymbolNames?: boolean);
+  /**
+       * Generates the complete container code as a string.
+       * @returns TypeScript source code for the generated container.
+       */
+  generate(): string;
+  /**
+       * Generates only the instantiation expression: new NeoContainer(...)
+       * This is used to replace defineBuilderConfig(...) in the source.
+       */
+  generateInstantiation(): string;
+  /**
+       * Sorts services in topological order (dependencies before dependents).
+       * @returns Array of TokenIds in dependency order.
+       */
+  private topologicalSort;
+  /**
+       * Creates a valid JavaScript function name from a token ID.
+       * @param tokenId - The token identifier.
+       * @returns A sanitized factory function name.
+       */
+  private getFactoryName;
+}
+//#endregion
+//#region src/generator/GraphValidator.d.ts
+/**
+ * Validates the dependency graph for correctness.
+ * Detects circular dependencies, missing bindings, and duplicates.
+ */
+declare class GraphValidator {
+  /**
+       * Validates the graph structure.
+       *
+       * @param graph - The dependency graph to validate.
+       * @throws {Error} If a circular dependency or missing binding is detected.
+       */
+  validate(graph: DependencyGraph): void;
+  /**
+       * Recursive Helper for Cycle Detection (DFS).
+       *
+       * @param nodeId - The current node ID.
+       * @param graph - The graph.
+       * @param visited - Set of all visited nodes.
+       * @param stack - Set of nodes in the current recursion stack (path).
+       * @param parentTokens - Tokens from parent container (skip traversal).
+       */
+  private detectCycle;
+}
+//#endregion
+export { Generator, GraphValidator };

package/dist/generator/index.d.mts

@@ -0,0 +1,69 @@
+import { t as DependencyGraph } from "../types-EnrcFw9C.mjs";
+
+//#region src/generator/Generator.d.ts
+/**
+ * Generates TypeScript code for the dependency injection container.
+ *
+ * Takes a validated dependency graph and produces:
+ * - Import statements for all dependencies
+ * - Factory functions for each service
+ * - A NeoContainer class with resolve logic
+ */
+declare class Generator {
+  private graph;
+  private useDirectSymbolNames;
+  /**
+       * Creates a new Generator.
+       * @param graph - The validated dependency graph to generate code from.
+       * @param useDirectSymbolNames - If true, uses symbol names directly without import prefixes.
+       */
+  constructor(graph: DependencyGraph, useDirectSymbolNames?: boolean);
+  /**
+       * Generates the complete container code as a string.
+       * @returns TypeScript source code for the generated container.
+       */
+  generate(): string;
+  /**
+       * Generates only the instantiation expression: new NeoContainer(...)
+       * This is used to replace defineBuilderConfig(...) in the source.
+       */
+  generateInstantiation(): string;
+  /**
+       * Sorts services in topological order (dependencies before dependents).
+       * @returns Array of TokenIds in dependency order.
+       */
+  private topologicalSort;
+  /**
+       * Creates a valid JavaScript function name from a token ID.
+       * @param tokenId - The token identifier.
+       * @returns A sanitized factory function name.
+       */
+  private getFactoryName;
+}
+//#endregion
+//#region src/generator/GraphValidator.d.ts
+/**
+ * Validates the dependency graph for correctness.
+ * Detects circular dependencies, missing bindings, and duplicates.
+ */
+declare class GraphValidator {
+  /**
+       * Validates the graph structure.
+       *
+       * @param graph - The dependency graph to validate.
+       * @throws {Error} If a circular dependency or missing binding is detected.
+       */
+  validate(graph: DependencyGraph): void;
+  /**
+       * Recursive Helper for Cycle Detection (DFS).
+       *
+       * @param nodeId - The current node ID.
+       * @param graph - The graph.
+       * @param visited - Set of all visited nodes.
+       * @param stack - Set of nodes in the current recursion stack (path).
+       * @param parentTokens - Tokens from parent container (skip traversal).
+       */
+  private detectCycle;
+}
+//#endregion
+export { Generator, GraphValidator };

package/dist/generator/index.mjs

@@ -0,0 +1,247 @@
+//#region src/generator/Generator.ts
+/**
+* Generates TypeScript code for the dependency injection container.
+*
+* Takes a validated dependency graph and produces:
+* - Import statements for all dependencies
+* - Factory functions for each service
+* - A NeoContainer class with resolve logic
+*/
+var Generator = class {
+	/**
+	* Creates a new Generator.
+	* @param graph - The validated dependency graph to generate code from.
+	* @param useDirectSymbolNames - If true, uses symbol names directly without import prefixes.
+	*/
+	constructor(graph, useDirectSymbolNames = false) {
+		this.graph = graph;
+		this.useDirectSymbolNames = useDirectSymbolNames;
+	}
+	/**
+	* Generates the complete container code as a string.
+	* @returns TypeScript source code for the generated container.
+	*/
+	generate() {
+		const sorted = this.topologicalSort();
+		const imports = /* @__PURE__ */ new Map();
+		const factories = [];
+		const resolveCases = [];
+		const getImport = (symbol) => {
+			if (this.useDirectSymbolNames) return symbol.getName();
+			const decl = symbol.declarations?.[0];
+			if (!decl) return "UNKNOWN";
+			const filePath = decl.getSourceFile().fileName;
+			if (!imports.has(filePath)) {
+				const alias = `Import_${imports.size}`;
+				imports.set(filePath, alias);
+			}
+			return `${imports.get(filePath)}.${symbol.getName()}`;
+		};
+		for (const tokenId of sorted) {
+			const node = this.graph.nodes.get(tokenId);
+			if (!node) continue;
+			if (node.service.type === "parent") continue;
+			const factoryId = this.getFactoryName(tokenId);
+			if (node.service.isFactory && node.service.factorySource) {
+				const userFactory = node.service.factorySource;
+				factories.push(`
+  private ${factoryId}(): any {
+    const userFactory = ${userFactory};
+    return userFactory(this);
+  }`);
+			} else {
+				const className = node.service.implementationSymbol ? getImport(node.service.implementationSymbol) : "undefined";
+				const args = node.dependencies.map((depId) => {
+					const depNode = this.graph.nodes.get(depId);
+					if (!depNode) return "undefined";
+					if (depNode.service.isInterfaceToken) return `this.resolve("${depNode.service.tokenId}")`;
+					else if (depNode.service.tokenSymbol) return `this.resolve(${getImport(depNode.service.tokenSymbol)})`;
+					else if (depNode.service.implementationSymbol) return `this.resolve(${getImport(depNode.service.implementationSymbol)})`;
+					return "undefined";
+				}).join(", ");
+				factories.push(`
+  private ${factoryId}(): any {
+    return new ${className}(${args});
+  }`);
+			}
+			const isTransient = node.service.lifecycle === "transient";
+			let tokenKey;
+			let tokenCheck;
+			if (node.service.isInterfaceToken) {
+				tokenKey = `"${node.service.tokenId}"`;
+				tokenCheck = `if (token === "${node.service.tokenId}")`;
+			} else if (node.service.tokenSymbol) {
+				const tokenClass = getImport(node.service.tokenSymbol);
+				tokenKey = tokenClass;
+				tokenCheck = `if (token === ${tokenClass})`;
+			} else if (node.service.implementationSymbol) {
+				const className = getImport(node.service.implementationSymbol);
+				tokenKey = className;
+				tokenCheck = `if (token === ${className})`;
+			} else {
+				tokenKey = `"${node.service.tokenId}"`;
+				tokenCheck = `if (token === "${node.service.tokenId}")`;
+			}
+			const creationLogic = isTransient ? `return this.${factoryId}();` : `
+            if (!this.instances.has(${tokenKey})) {
+                const instance = this.${factoryId}();
+                this.instances.set(${tokenKey}, instance);
+                return instance;
+            }
+            return this.instances.get(${tokenKey});
+          `;
+			resolveCases.push(`${tokenCheck} { ${creationLogic} }`);
+		}
+		const importLines = [];
+		if (!this.useDirectSymbolNames) for (const [filePath, alias] of imports) importLines.push(`import * as ${alias} from '${filePath}';`);
+		return `
+${importLines.join("\n")}
+
+// -- Container --
+export class NeoContainer {
+  private instances = new Map<any, any>();
+
+  // -- Factories --
+  ${factories.join("\n  ")}
+
+  constructor(
+    private parent?: any,
+    private legacy?: any[],
+    private name: string = 'NeoContainer'
+  ) {}
+
+  public resolve(token: any): any {
+    // 1. Try to resolve locally (or create if singleton)
+    const result = this.resolveLocal(token);
+    if (result !== undefined) return result;
+
+    // 2. Delegate to parent
+    if (this.parent) {
+        try {
+            return this.parent.resolve(token);
+        } catch (e) {
+            // Ignore error, try legacy
+        }
+    }
+
+    // 3. Delegate to legacy
+    if (this.legacy) {
+        for (const legacyContainer of this.legacy) {
+            // Assume legacy container has resolve()
+            try {
+                if (legacyContainer.resolve) return legacyContainer.resolve(token);
+            } catch (e) {
+                // Ignore
+            }
+        }
+    }
+
+    throw new Error(\`[\${this.name}] Service not found or token not registered: \${token}\`);
+  }
+
+  private resolveLocal(token: any): any {
+    ${resolveCases.join("\n    ")}
+    return undefined;
+  }
+
+  // For debugging/inspection
+  public get _graph() {
+    return ${JSON.stringify(Array.from(this.graph.nodes.keys()))};
+  }
+}
+${this.useDirectSymbolNames ? "" : `
+// -- Container Instance --
+export const ${this.graph.exportedVariableName || "container"} = ${this.generateInstantiation()};
+`}`;
+	}
+	/**
+	* Generates only the instantiation expression: new NeoContainer(...)
+	* This is used to replace defineBuilderConfig(...) in the source.
+	*/
+	generateInstantiation() {
+		return `new NeoContainer(${this.graph.buildArguments && this.graph.buildArguments.length > 0 ? this.graph.buildArguments[0] : "undefined"}, ${this.graph.legacyContainers ? `[${this.graph.legacyContainers.join(", ")}]` : "undefined"}, ${this.graph.containerName ? `'${this.graph.containerName}'` : "undefined"})`;
+	}
+	/**
+	* Sorts services in topological order (dependencies before dependents).
+	* @returns Array of TokenIds in dependency order.
+	*/
+	topologicalSort() {
+		const visited = /* @__PURE__ */ new Set();
+		const sorted = [];
+		const visit = (id) => {
+			if (visited.has(id)) return;
+			visited.add(id);
+			const node = this.graph.nodes.get(id);
+			if (node) {
+				for (const depId of node.dependencies) visit(depId);
+				sorted.push(id);
+			}
+		};
+		for (const id of this.graph.nodes.keys()) visit(id);
+		return sorted;
+	}
+	/**
+	* Creates a valid JavaScript function name from a token ID.
+	* @param tokenId - The token identifier.
+	* @returns A sanitized factory function name.
+	*/
+	getFactoryName(tokenId) {
+		return `create_${tokenId.replace(/[^a-zA-Z0-9]/g, "_")}`;
+	}
+};
+
+//#endregion
+//#region src/generator/GraphValidator.ts
+/**
+* Validates the dependency graph for correctness.
+* Detects circular dependencies, missing bindings, and duplicates.
+*/
+var GraphValidator = class {
+	/**
+	* Validates the graph structure.
+	*
+	* @param graph - The dependency graph to validate.
+	* @throws {Error} If a circular dependency or missing binding is detected.
+	*/
+	validate(graph) {
+		const visited = /* @__PURE__ */ new Set();
+		const recursionStack = /* @__PURE__ */ new Set();
+		const parentTokens = graph.parentProvidedTokens ?? /* @__PURE__ */ new Set();
+		for (const [nodeId, node] of graph.nodes) if (parentTokens.has(nodeId)) {
+			if (node.service.isScoped) continue;
+			throw new Error(`Duplicate registration: '${nodeId}' is already registered in the parent container. Use 'scoped: true' to override the parent's registration intentionally.`);
+		}
+		for (const [nodeId, node] of graph.nodes) for (const depId of node.dependencies) {
+			const isProvidedLocally = graph.nodes.has(depId);
+			const isProvidedByParent = parentTokens.has(depId);
+			if (!isProvidedLocally && !isProvidedByParent) {
+				const serviceName = nodeId;
+				throw new Error(`Missing binding: Service '${serviceName}' depends on '${depId}', but no provider was registered.`);
+			}
+		}
+		for (const nodeId of graph.nodes.keys()) if (!visited.has(nodeId)) this.detectCycle(nodeId, graph, visited, recursionStack, parentTokens);
+	}
+	/**
+	* Recursive Helper for Cycle Detection (DFS).
+	*
+	* @param nodeId - The current node ID.
+	* @param graph - The graph.
+	* @param visited - Set of all visited nodes.
+	* @param stack - Set of nodes in the current recursion stack (path).
+	* @param parentTokens - Tokens from parent container (skip traversal).
+	*/
+	detectCycle(nodeId, graph, visited, stack, parentTokens) {
+		visited.add(nodeId);
+		stack.add(nodeId);
+		const node = graph.nodes.get(nodeId);
+		if (node) for (const depId of node.dependencies) {
+			if (parentTokens.has(depId)) continue;
+			if (!visited.has(depId)) this.detectCycle(depId, graph, visited, stack, parentTokens);
+			else if (stack.has(depId)) throw new Error(`Circular dependency detected: ${[...stack, depId].join(" -> ")}`);
+		}
+		stack.delete(nodeId);
+	}
+};
+
+//#endregion
+export { Generator, GraphValidator };

package/dist/types-DeLOEpiR.d.cts

@@ -0,0 +1,84 @@
+import { Node, Symbol } from "typescript";
+
+//#region src/analyzer/types.d.ts
+/**
+ * Unique identifier for a token (interface name or class name).
+ */
+type TokenId = string;
+/**
+ * How a service was registered in the container.
+ * - `explicit`: Provider was explicitly specified.
+ * - `autowire`: Token is both the token and provider (self-binding).
+ * - `parent`: Inherited from parent container.
+ * - `factory`: Provider is a factory function.
+ */
+type RegistrationType = 'explicit' | 'autowire' | 'parent' | 'factory';
+/**
+ * Represents a single service definition in the dependency graph.
+ */
+interface ServiceDefinition {
+  /** Unique identifier for this service token. */
+  tokenId: TokenId;
+  /**
+       * The TypeScript symbol of the concrete class implementation.
+       * Undefined if the provider is a factory function.
+       */
+  implementationSymbol?: Symbol;
+  /**
+       * The TypeScript symbol of the token (if it is a Class/Value).
+       * Undefined if the token is a virtual interface ID.
+       */
+  tokenSymbol?: Symbol;
+  /** The source node where the registration happened (for error reporting). */
+  registrationNode: Node;
+  /** How this service was registered. */
+  type: RegistrationType;
+  /** Lifecycle of the service instance. */
+  lifecycle: 'singleton' | 'transient';
+  /** True if the token is an interface (requires string literal key). */
+  isInterfaceToken?: boolean;
+  /** True if the token is a value token for primitives. */
+  isValueToken?: boolean;
+  /** True if the provider is a factory function. */
+  isFactory?: boolean;
+  /** The raw source text of the factory function (for code generation). */
+  factorySource?: string;
+  /** True if this injection is scoped to the local container. */
+  isScoped?: boolean;
+}
+/**
+ * A node in the dependency graph representing a service and its dependencies.
+ */
+interface DependencyNode {
+  /** The service definition. */
+  service: ServiceDefinition;
+  /** Token IDs of dependencies required by this service's constructor. */
+  dependencies: TokenId[];
+}
+/**
+ * Complete dependency graph for a container configuration.
+ */
+interface DependencyGraph {
+  /** All service nodes indexed by their token ID. */
+  nodes: Map<TokenId, DependencyNode>;
+  /** Root services that are explicitly requested or exported. */
+  roots: TokenId[];
+  /** Arguments passed to the .build() method call (raw source text). */
+  buildArguments?: string[];
+  /** Optional container name for debugging. */
+  containerName?: string;
+  /** The exported variable name used for the container (e.g., 'appContainer'). */
+  exportedVariableName?: string;
+  /** Start position of the variable statement containing defineBuilderConfig (where to insert generated code). */
+  variableStatementStart?: number;
+  /** Start position of the defineBuilderConfig expression in the source file. */
+  defineBuilderConfigStart?: number;
+  /** End position of the defineBuilderConfig expression in the source file. */
+  defineBuilderConfigEnd?: number;
+  /** Legacy container variable names to delegate to. */
+  legacyContainers?: string[];
+  /** Tokens provided by the parent container (used for validation). */
+  parentProvidedTokens?: Set<TokenId>;
+}
+//#endregion
+export { TokenId as a, ServiceDefinition as i, DependencyNode as n, RegistrationType as r, DependencyGraph as t };

package/dist/types-EnrcFw9C.d.mts

@@ -0,0 +1,84 @@
+import { Node, Symbol } from "typescript";
+
+//#region src/analyzer/types.d.ts
+/**
+ * Unique identifier for a token (interface name or class name).
+ */
+type TokenId = string;
+/**
+ * How a service was registered in the container.
+ * - `explicit`: Provider was explicitly specified.
+ * - `autowire`: Token is both the token and provider (self-binding).
+ * - `parent`: Inherited from parent container.
+ * - `factory`: Provider is a factory function.
+ */
+type RegistrationType = 'explicit' | 'autowire' | 'parent' | 'factory';
+/**
+ * Represents a single service definition in the dependency graph.
+ */
+interface ServiceDefinition {
+  /** Unique identifier for this service token. */
+  tokenId: TokenId;
+  /**
+       * The TypeScript symbol of the concrete class implementation.
+       * Undefined if the provider is a factory function.
+       */
+  implementationSymbol?: Symbol;
+  /**
+       * The TypeScript symbol of the token (if it is a Class/Value).
+       * Undefined if the token is a virtual interface ID.
+       */
+  tokenSymbol?: Symbol;
+  /** The source node where the registration happened (for error reporting). */
+  registrationNode: Node;
+  /** How this service was registered. */
+  type: RegistrationType;
+  /** Lifecycle of the service instance. */
+  lifecycle: 'singleton' | 'transient';
+  /** True if the token is an interface (requires string literal key). */
+  isInterfaceToken?: boolean;
+  /** True if the token is a value token for primitives. */
+  isValueToken?: boolean;
+  /** True if the provider is a factory function. */
+  isFactory?: boolean;
+  /** The raw source text of the factory function (for code generation). */
+  factorySource?: string;
+  /** True if this injection is scoped to the local container. */
+  isScoped?: boolean;
+}
+/**
+ * A node in the dependency graph representing a service and its dependencies.
+ */
+interface DependencyNode {
+  /** The service definition. */
+  service: ServiceDefinition;
+  /** Token IDs of dependencies required by this service's constructor. */
+  dependencies: TokenId[];
+}
+/**
+ * Complete dependency graph for a container configuration.
+ */
+interface DependencyGraph {
+  /** All service nodes indexed by their token ID. */
+  nodes: Map<TokenId, DependencyNode>;
+  /** Root services that are explicitly requested or exported. */
+  roots: TokenId[];
+  /** Arguments passed to the .build() method call (raw source text). */
+  buildArguments?: string[];
+  /** Optional container name for debugging. */
+  containerName?: string;
+  /** The exported variable name used for the container (e.g., 'appContainer'). */
+  exportedVariableName?: string;
+  /** Start position of the variable statement containing defineBuilderConfig (where to insert generated code). */
+  variableStatementStart?: number;
+  /** Start position of the defineBuilderConfig expression in the source file. */
+  defineBuilderConfigStart?: number;
+  /** End position of the defineBuilderConfig expression in the source file. */
+  defineBuilderConfigEnd?: number;
+  /** Legacy container variable names to delegate to. */
+  legacyContainers?: string[];
+  /** Tokens provided by the parent container (used for validation). */
+  parentProvidedTokens?: Set<TokenId>;
+}
+//#endregion
+export { TokenId as a, ServiceDefinition as i, DependencyNode as n, RegistrationType as r, DependencyGraph as t };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@djodjonx/neosyringe-core",
+  "version": "0.1.0",
+  "description": "Core analysis and generation logic for NeoSyringe",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./analyzer": {
+      "types": "./dist/analyzer/index.d.mts",
+      "import": "./dist/analyzer/index.mjs",
+      "require": "./dist/analyzer/index.cjs"
+    },
+    "./generator": {
+      "types": "./dist/generator/index.d.mts",
+      "import": "./dist/generator/index.mjs",
+      "require": "./dist/generator/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@djodjonx/neosyringe": "0.1.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}