adnbn 0.2.4 → 0.2.6

package/dist/cli/bundler/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { isEntryModuleOrIssuer, onlyViaTopLevelEntry } from './optimization.js';
+export { appFilenameResolver } from './output.js';
+import '@rspack/core';

package/dist/cli/bundler/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./optimization.js";
+export * from "./output.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/bundler/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/bundler/utils/index.ts"],"sourcesContent":["export * from \"./optimization\";\nexport * from \"./output\";\n"],"mappings":"AAAA,cAAc;AACd,cAAc;","names":[]}

package/dist/cli/bundler/utils/optimization.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationSplitChunksCacheGroupTestFn } from '@rspack/core';
+
+declare const onlyViaTopLevelEntry: (entry: string | string[]) => OptimizationSplitChunksCacheGroupTestFn;
+declare const isEntryModuleOrIssuer: (entry: string | string[]) => OptimizationSplitChunksCacheGroupTestFn;
+
+export { isEntryModuleOrIssuer, onlyViaTopLevelEntry };

package/dist/cli/bundler/utils/optimization.js

@@ -0,0 +1,106 @@
+import path from "path";
+import { PackageName } from "./../../../types/app.js";
+const getEntryDirs = (entry) => {
+  const entries = Array.isArray(entry) ? entry : [entry];
+  if (entries.length === 0) {
+    return [];
+  }
+  return entries.flatMap((v) => [
+    path.join("node_modules", PackageName, "dist", "entry", v),
+    path.join("addonbone", "dist", "entry", v)
+    // TODO: Only for test. Remove this
+  ]);
+};
+const onlyViaTopLevelEntry = (entry) => {
+  const entryDirs = getEntryDirs(entry);
+  if (entryDirs.length === 0) {
+    return () => false;
+  }
+  const isTargetRes = (res) => !!res && entryDirs.some((dir) => res.includes(dir));
+  const memoTopLevelTarget = /* @__PURE__ */ new WeakMap();
+  const memoPathOk = /* @__PURE__ */ new WeakMap();
+  const isTopLevelTarget = (m, mg) => {
+    if (!m) {
+      return false;
+    }
+    const cached = memoTopLevelTarget.get(m);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const ok = isTargetRes(m.resource) && (() => {
+      const issuer = mg.getIssuer(m);
+      return !!issuer && !mg.getIssuer(issuer);
+    })();
+    memoTopLevelTarget.set(m, ok);
+    return ok;
+  };
+  const pathHasTopLevelTarget = (start, mg) => {
+    if (!start) {
+      return false;
+    }
+    const cached = memoPathOk.get(start);
+    if (cached !== void 0) {
+      return cached;
+    }
+    let cur = start;
+    let steps = 0;
+    const MAX_STEPS = 1024;
+    while (cur && steps++ < MAX_STEPS) {
+      if (isTopLevelTarget(cur, mg)) {
+        memoPathOk.set(start, true);
+        return true;
+      }
+      cur = mg.getIssuer(cur);
+    }
+    memoPathOk.set(start, false);
+    return false;
+  };
+  return (module, { moduleGraph }) => {
+    const nm = module;
+    const res = nm.resource;
+    if (!res) {
+      return false;
+    }
+    if (isTargetRes(res)) return true;
+    const conns = moduleGraph.getIncomingConnections(nm);
+    if (!conns || conns.length === 0) {
+      return false;
+    }
+    for (let i = 0; i < conns.length; i++) {
+      const origin = conns[i].originModule;
+      if (!pathHasTopLevelTarget(origin, moduleGraph)) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+const isEntryModuleOrIssuer = (entry) => {
+  const entryDirs = getEntryDirs(entry);
+  if (entryDirs.length === 0) {
+    return () => false;
+  }
+  return (module, { moduleGraph }) => {
+    const nm = module;
+    const resource = nm.resource || "";
+    if (entryDirs.some((dir) => resource.includes(dir))) {
+      return true;
+    }
+    for (const connection of moduleGraph.getIncomingConnections(nm)) {
+      const origin = connection.originModule;
+      if (!(origin == null ? void 0 : origin.resource)) {
+        continue;
+      }
+      const originRes = origin.resource;
+      if (entryDirs.some((dir) => originRes.includes(dir))) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+export {
+  isEntryModuleOrIssuer,
+  onlyViaTopLevelEntry
+};
+//# sourceMappingURL=optimization.js.map

package/dist/cli/bundler/utils/optimization.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/bundler/utils/optimization.ts"],"sourcesContent":["import path from \"path\";\nimport {NormalModule, type OptimizationSplitChunksCacheGroupTestFn} from \"@rspack/core\";\n\nimport {PackageName} from \"@typing/app\";\n\nconst getEntryDirs = (entry: string | string[]): string[] => {\n    const entries = Array.isArray(entry) ? entry : [entry];\n\n    if (entries.length === 0) {\n        return [];\n    }\n\n    return entries.flatMap(v => [\n        path.join(\"node_modules\", PackageName, \"dist\", \"entry\", v),\n        path.join(\"addonbone\", \"dist\", \"entry\", v), // TODO: Only for test. Remove this\n    ]);\n};\n\nexport const onlyViaTopLevelEntry = (entry: string | string[]): OptimizationSplitChunksCacheGroupTestFn => {\n    const entryDirs = getEntryDirs(entry);\n\n    if (entryDirs.length === 0) {\n        return () => false;\n    }\n\n    const isTargetRes = (res?: string) => !!res && entryDirs.some(dir => res!.includes(dir));\n\n    const memoTopLevelTarget = new WeakMap<object, boolean>();\n    const memoPathOk = new WeakMap<object, boolean>();\n\n    const isTopLevelTarget = (m: NormalModule | undefined, mg: any): boolean => {\n        if (!m) {\n            return false;\n        }\n\n        const cached = memoTopLevelTarget.get(m);\n\n        if (cached !== undefined) {\n            return cached;\n        }\n\n        const ok =\n            isTargetRes(m.resource) &&\n            (() => {\n                const issuer = mg.getIssuer(m) as NormalModule | undefined;\n                return !!issuer && !mg.getIssuer(issuer);\n            })();\n\n        memoTopLevelTarget.set(m, ok);\n\n        return ok;\n    };\n\n    const pathHasTopLevelTarget = (start: NormalModule | undefined, mg: any): boolean => {\n        if (!start) {\n            return false;\n        }\n\n        const cached = memoPathOk.get(start);\n\n        if (cached !== undefined) {\n            return cached;\n        }\n\n        let cur: NormalModule | undefined = start;\n        let steps = 0;\n\n        const MAX_STEPS = 1024;\n\n        while (cur && steps++ < MAX_STEPS) {\n            if (isTopLevelTarget(cur, mg)) {\n                memoPathOk.set(start, true);\n                return true;\n            }\n\n            cur = mg.getIssuer(cur) as NormalModule | undefined;\n        }\n\n        memoPathOk.set(start, false);\n\n        return false;\n    };\n\n    return (module, {moduleGraph}) => {\n        const nm = module as NormalModule;\n        const res = nm.resource;\n\n        if (!res) {\n            return false;\n        }\n\n        if (isTargetRes(res)) return true;\n\n        const conns = moduleGraph.getIncomingConnections(nm);\n\n        if (!conns || conns.length === 0) {\n            return false;\n        }\n\n        for (let i = 0; i < conns.length; i++) {\n            const origin = conns[i].originModule as NormalModule | undefined;\n\n            if (!pathHasTopLevelTarget(origin, moduleGraph)) {\n                return false;\n            }\n        }\n\n        return true;\n    };\n};\n\nexport const isEntryModuleOrIssuer = (entry: string | string[]): OptimizationSplitChunksCacheGroupTestFn => {\n    const entryDirs = getEntryDirs(entry);\n\n    if (entryDirs.length === 0) {\n        return () => false;\n    }\n\n    return (module, {moduleGraph}) => {\n        const nm = module as NormalModule;\n        const resource = nm.resource || \"\";\n\n        if (entryDirs.some(dir => resource.includes(dir))) {\n            return true;\n        }\n\n        for (const connection of moduleGraph.getIncomingConnections(nm)) {\n            const origin = connection.originModule as NormalModule | undefined;\n\n            if (!origin?.resource) {\n                continue;\n            }\n\n            const originRes = origin.resource;\n\n            if (entryDirs.some(dir => originRes.includes(dir))) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n};\n"],"mappings":"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","names":[]}

package/dist/cli/bundler/utils/output.d.ts

@@ -0,0 +1,5 @@
+import { Filename } from '@rspack/core';
+
+declare const appFilenameResolver: (app: string, filename: Filename, dirname?: string) => Extract<Filename, Filename>;
+
+export { appFilenameResolver };

package/dist/cli/bundler/utils/output.js

@@ -0,0 +1,15 @@
+import _ from "lodash";
+import path from "path";
+const appFilenameResolver = (app, filename, dirname) => (pathData, assetInfo) => {
+  app = _.kebabCase(app);
+  let name = _.isFunction(filename) ? filename(pathData, assetInfo) : filename;
+  name = name.replaceAll("[app]", app);
+  if (dirname) {
+    return path.posix.join(dirname, name);
+  }
+  return name;
+};
+export {
+  appFilenameResolver
+};
+//# sourceMappingURL=output.js.map

package/dist/cli/bundler/utils/output.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/bundler/utils/output.ts"],"sourcesContent":["import {Filename} from \"@rspack/core\";\nimport _ from \"lodash\";\nimport path from \"path\";\n\n// prettier-ignore\nexport const appFilenameResolver =\n    (app: string, filename: Filename, dirname?: string): Extract<Filename, Filename> =>\n        (pathData, assetInfo): string => {\n            app = _.kebabCase(app);\n\n            let name = _.isFunction(filename) ? filename(pathData, assetInfo) : filename;\n\n            name = name.replaceAll(\"[app]\", app);\n\n            if (dirname) {\n                return path.posix.join(dirname, name);\n            }\n\n            return name;\n        };\n"],"mappings":"AACA,OAAO,OAAO;AACd,OAAO,UAAU;AAGV,MAAM,sBACT,CAAC,KAAa,UAAoB,YAC9B,CAAC,UAAU,cAAsB;AAC7B,QAAM,EAAE,UAAU,GAAG;AAErB,MAAI,OAAO,EAAE,WAAW,QAAQ,IAAI,SAAS,UAAU,SAAS,IAAI;AAEpE,SAAO,KAAK,WAAW,SAAS,GAAG;AAEnC,MAAI,SAAS;AACT,WAAO,KAAK,MAAM,KAAK,SAAS,IAAI;AAAA,EACxC;AAEA,SAAO;AACX;","names":[]}

package/dist/cli/entrypoint/file/ExpressionFile.d.ts

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import EntryFile from './SourceFile.js';
+import { MemberSignature } from './parsers/types.js';
+import './resolvers/ImportResolver.js';
+import './resolvers/TsResolver.js';
+import './types.js';
+
+/**
+ * Parses a TypeScript expression (object literal, function, or class)
+ * and builds a full interface of its public members (methods and properties).
+ */
+declare class ExpressionFile extends EntryFile {
+    protected property?: string;
+    /**
+     * Names of wrapper functions whose first argument should be unwrapped for parsing.
+     */
+    protected definition: Set<string>;
+    private readonly typeResolver;
+    private readonly nodeFinder;
+    private readonly signatureBuilder;
+    private readonly functionParser;
+    private readonly objectParser;
+    private readonly classParser;
+    private readonly jsDocParser;
+    constructor(filePath: string);
+    getType(): string | undefined;
+    setProperty(property: string): this;
+    /**
+     * Entry point: accepts an expression and returns a map of member signatures,
+     * or undefined if the expression cannot be parsed.
+     */
+    protected parse(expr: ts.Expression): Record<string, MemberSignature> | undefined;
+    /**
+     * Specify wrapper functions whose first argument should be unwrapped for parsing.
+     */
+    setDefinition(definition: string | string[]): this;
+    /**
+     * Recursively unwraps type assertions, satisfies, parentheses, and allowed wrapper calls.
+     */
+    private unwrapExpression;
+    /**
+     * Given an initializer or expression, extracts its type: function signature or interface.
+     */
+    private getTypeFromInitializer;
+    /**
+     * Extracts the type of the return value of a method, taking into account JSDoc annotations.
+     *
+     * @param method The method declaration to extract the return type from
+     * @returns The extracted return type as a string, or undefined if it cannot be extracted
+     */
+    private getTypeFromMethodReturn;
+}
+
+export { ExpressionFile as default };

package/dist/cli/entrypoint/file/ExpressionFile.js

@@ -0,0 +1,271 @@
+import ts from "typescript";
+import SourceFile from "./SourceFile.js";
+import {
+  ClassParser,
+  FunctionParser,
+  JSDocParser,
+  NodeFinder,
+  ObjectParser,
+  SignatureBuilder,
+  TypeResolver
+} from "./parsers/index.js";
+import { PackageName } from "./../../../types/app.js";
+class ExpressionFile extends SourceFile {
+  property;
+  /**
+   * Names of wrapper functions whose first argument should be unwrapped for parsing.
+   */
+  definition = /* @__PURE__ */ new Set();
+  typeResolver;
+  nodeFinder;
+  signatureBuilder;
+  functionParser;
+  objectParser;
+  classParser;
+  jsDocParser;
+  constructor(filePath) {
+    super(filePath);
+    this.typeResolver = new TypeResolver(this);
+    this.nodeFinder = new NodeFinder(this);
+    this.signatureBuilder = new SignatureBuilder(this.typeResolver);
+    this.objectParser = new ObjectParser(this, this.signatureBuilder);
+    this.classParser = new ClassParser(this, this.typeResolver, this.signatureBuilder, this.nodeFinder);
+    this.functionParser = new FunctionParser(this, this.nodeFinder, this.objectParser, this.classParser);
+    this.jsDocParser = new JSDocParser();
+  }
+  getType() {
+    if (this.property) {
+      const varDecl = this.nodeFinder.findVariableDeclaration(this.property);
+      if (varDecl && varDecl.initializer) {
+        return this.getTypeFromInitializer(varDecl.initializer);
+      }
+      let exportExpr;
+      const sf2 = this.getSourceFile();
+      const findExport = (node) => {
+        if (ts.isExportAssignment(node)) {
+          exportExpr = node.expression;
+        }
+        ts.forEachChild(node, findExport);
+      };
+      findExport(sf2);
+      if (!exportExpr) return void 0;
+      if (this.definition.size > 0 && ts.isCallExpression(exportExpr) && ts.isIdentifier(exportExpr.expression)) {
+        const fnName = exportExpr.expression.text;
+        if (this.definition.has(fnName)) {
+          let importPath;
+          try {
+            importPath = this.getImports().get(fnName);
+          } catch {
+            return void 0;
+          }
+          if (importPath !== PackageName) {
+            console.warn(`Function ${fnName} is not imported from '${PackageName}' in file ${this.file}`);
+            return void 0;
+          }
+          if (exportExpr.arguments.length > 0) {
+            const firstArg = exportExpr.arguments[0];
+            if (ts.isObjectLiteralExpression(firstArg)) {
+              for (const prop of firstArg.properties) {
+                const key = this.objectParser.getName(prop.name ?? prop);
+                if (key !== this.property) continue;
+                if (ts.isPropertyAssignment(prop)) {
+                  const initType = this.getTypeFromInitializer(prop.initializer);
+                  if (initType) return initType;
+                } else if (ts.isMethodDeclaration(prop)) {
+                  const returnType = this.getTypeFromMethodReturn(prop);
+                  if (returnType) return returnType;
+                }
+              }
+            }
+          }
+        }
+      }
+      const expr = this.unwrapExpression(exportExpr);
+      if (ts.isObjectLiteralExpression(expr)) {
+        for (const prop of expr.properties) {
+          const key = this.objectParser.getName(prop.name ?? prop);
+          if (key !== this.property) continue;
+          if (ts.isPropertyAssignment(prop)) {
+            return this.getTypeFromInitializer(prop.initializer);
+          } else if (ts.isMethodDeclaration(prop) || ts.isGetAccessorDeclaration(prop)) {
+            const sig = this.signatureBuilder.getMethodSignature(prop);
+            return this.signatureBuilder.buildFunctionType(sig);
+          } else if (ts.isShorthandPropertyAssignment(prop)) {
+            const name = prop.name.text;
+            const variable = this.getVariables().get(name);
+            if (variable) {
+              const val = variable.value;
+              switch (typeof val) {
+                case "string":
+                  return "string";
+                case "number":
+                  return "number";
+                case "boolean":
+                  return "boolean";
+                case "object":
+                  if (val === null) return "null";
+                  if (Array.isArray(val)) return "array";
+                  return "object";
+                default:
+                  return "any";
+              }
+            }
+            return "any";
+          }
+        }
+        return void 0;
+      }
+      return this.getTypeFromInitializer(expr);
+    }
+    let members;
+    const sf = this.getSourceFile();
+    const collect = (node) => {
+      if (ts.isExportAssignment(node)) {
+        const expr0 = node.expression;
+        const expr = this.unwrapExpression(expr0);
+        const parsed = this.parse(expr);
+        if (parsed) members = parsed;
+      }
+      ts.forEachChild(node, collect);
+    };
+    collect(sf);
+    if (!members) return void 0;
+    return this.signatureBuilder.formatMembers(members);
+  }
+  setProperty(property) {
+    this.property = property;
+    return this;
+  }
+  /**
+   * Entry point: accepts an expression and returns a map of member signatures,
+   * or undefined if the expression cannot be parsed.
+   */
+  parse(expr) {
+    if (ts.isFunctionExpression(expr) || ts.isArrowFunction(expr)) {
+      return this.functionParser.parse(expr);
+    } else if (ts.isObjectLiteralExpression(expr)) {
+      return this.objectParser.parse(expr);
+    } else if (ts.isClassExpression(expr)) {
+      return this.classParser.parse(expr);
+    }
+    return void 0;
+  }
+  /**
+   * Specify wrapper functions whose first argument should be unwrapped for parsing.
+   */
+  setDefinition(definition) {
+    const defs = typeof definition === "string" ? [definition] : definition;
+    defs.forEach((def) => this.definition.add(def));
+    return this;
+  }
+  /**
+   * Recursively unwraps type assertions, satisfies, parentheses, and allowed wrapper calls.
+   */
+  unwrapExpression(expr) {
+    expr = this.functionParser.unwrapExpression(expr);
+    if (ts.isAsExpression(expr)) {
+      return this.unwrapExpression(expr.expression);
+    }
+    if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+      const fnName = expr.expression.text;
+      if (this.definition.has(fnName)) {
+        let importPath;
+        try {
+          importPath = this.getImports().get(fnName);
+        } catch {
+          return expr;
+        }
+        if (importPath !== PackageName) {
+          console.warn(`Function ${fnName} is not imported from '${PackageName}' in file ${this.file}`);
+        } else if (expr.arguments.length > 0) {
+          const first = expr.arguments[0];
+          return this.unwrapExpression(first);
+        }
+      }
+    }
+    return expr;
+  }
+  /**
+   * Given an initializer or expression, extracts its type: function signature or interface.
+   */
+  getTypeFromInitializer(node) {
+    if (ts.isAsExpression(node)) {
+      return this.getTypeFromInitializer(node.expression);
+    }
+    if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+      const members2 = this.functionParser.parse(node);
+      if (members2) {
+        return this.signatureBuilder.formatMembers(members2);
+      }
+      const sig = this.signatureBuilder.getMethodSignature(node);
+      return this.signatureBuilder.buildFunctionType(sig);
+    }
+    if (ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node)) {
+      const sig = this.signatureBuilder.getMethodSignature(node);
+      return this.signatureBuilder.buildFunctionType(sig);
+    }
+    let members;
+    if (ts.isObjectLiteralExpression(node) || ts.isClassExpression(node) || ts.isClassDeclaration(node)) {
+      members = this.parse(node);
+    } else if (ts.isNewExpression(node)) {
+      const ctor = node.expression;
+      if (ts.isIdentifier(ctor)) {
+        members = this.classParser.parseFileClass(ctor.text);
+      } else if (ts.isClassExpression(ctor)) {
+        members = this.classParser.parse(ctor);
+      }
+    }
+    if (members) {
+      return this.signatureBuilder.formatMembers(members);
+    }
+    if (ts.isLiteralExpression(node) || ts.isArrayLiteralExpression(node) || ts.isObjectLiteralExpression(node)) {
+      return this.objectParser.inferTypeFromExpression(node);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts the type of the return value of a method, taking into account JSDoc annotations.
+   *
+   * @param method The method declaration to extract the return type from
+   * @returns The extracted return type as a string, or undefined if it cannot be extracted
+   */
+  getTypeFromMethodReturn(method) {
+    if (method.body) {
+      const jsDocReturnType = this.jsDocParser.getJSDocReturnType(method);
+      if (jsDocReturnType) {
+        if (jsDocReturnType.includes("new ")) {
+          const className = jsDocReturnType.replace("new ", "").trim();
+          const members2 = this.classParser.parseFileClass(className);
+          if (members2) {
+            return this.signatureBuilder.formatMembers(members2);
+          }
+        }
+        const members = this.classParser.parseFileClass(jsDocReturnType);
+        if (members) {
+          return this.signatureBuilder.formatMembers(members);
+        }
+        return jsDocReturnType;
+      }
+      let returnExpr;
+      const findReturn = (node) => {
+        if (ts.isReturnStatement(node) && node.expression) {
+          returnExpr = node.expression;
+          return;
+        }
+        ts.forEachChild(node, findReturn);
+      };
+      findReturn(method.body);
+      if (returnExpr) {
+        return this.getTypeFromInitializer(returnExpr);
+      }
+    }
+    if (method.type) {
+      return this.typeResolver.resolveTypeNode(method.type);
+    }
+    return void 0;
+  }
+}
+export {
+  ExpressionFile as default
+};
+//# sourceMappingURL=ExpressionFile.js.map

package/dist/cli/entrypoint/file/ExpressionFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/entrypoint/file/ExpressionFile.ts"],"sourcesContent":["import ts from \"typescript\";\n\nimport SourceFile from \"./SourceFile\";\nimport {\n    ClassParser,\n    FunctionParser,\n    JSDocParser,\n    NodeFinder,\n    ObjectParser,\n    SignatureBuilder,\n    TypeResolver,\n} from \"./parsers\";\nimport {MemberSignature} from \"./parsers/types\";\n\nimport {PackageName} from \"@typing/app\";\n\n/**\n * Parses a TypeScript expression (object literal, function, or class)\n * and builds a full interface of its public members (methods and properties).\n */\nexport default class ExpressionFile extends SourceFile {\n    protected property?: string;\n    /**\n     * Names of wrapper functions whose first argument should be unwrapped for parsing.\n     */\n    protected definition = new Set<string>();\n\n    private readonly typeResolver: TypeResolver;\n    private readonly nodeFinder: NodeFinder;\n    private readonly signatureBuilder: SignatureBuilder;\n    private readonly functionParser: FunctionParser;\n    private readonly objectParser: ObjectParser;\n    private readonly classParser: ClassParser;\n    private readonly jsDocParser: JSDocParser;\n    constructor(filePath: string) {\n        super(filePath);\n\n        this.typeResolver = new TypeResolver(this);\n        this.nodeFinder = new NodeFinder(this);\n        this.signatureBuilder = new SignatureBuilder(this.typeResolver);\n        this.objectParser = new ObjectParser(this, this.signatureBuilder);\n        this.classParser = new ClassParser(this, this.typeResolver, this.signatureBuilder, this.nodeFinder);\n        this.functionParser = new FunctionParser(this, this.nodeFinder, this.objectParser, this.classParser);\n        this.jsDocParser = new JSDocParser();\n    }\n\n    public getType(): string | undefined {\n        // If a specific variable or property is requested, extract its type\n        if (this.property) {\n            // 1) Named variable scenario: e.g. export const init = () => ...\n            const varDecl = this.nodeFinder.findVariableDeclaration(this.property);\n\n            if (varDecl && varDecl.initializer) {\n                return this.getTypeFromInitializer(varDecl.initializer);\n            }\n\n            // 2) Property on default export object: unwrap and look up key\n            let exportExpr: ts.Expression | undefined;\n            const sf = this.getSourceFile();\n\n            const findExport = (node: ts.Node) => {\n                if (ts.isExportAssignment(node)) {\n                    exportExpr = node.expression;\n                }\n                ts.forEachChild(node, findExport);\n            };\n\n            findExport(sf);\n\n            if (!exportExpr) return undefined;\n\n            // Special case for service definitions with JSDoc annotations\n            if (this.definition.size > 0 && ts.isCallExpression(exportExpr) && ts.isIdentifier(exportExpr.expression)) {\n                const fnName = exportExpr.expression.text;\n\n                if (this.definition.has(fnName)) {\n                    // Check if the wrapper function is imported from the designated package name\n                    let importPath: string | undefined;\n                    try {\n                        importPath = this.getImports().get(fnName);\n                    } catch {\n                        // unable to resolve import source -> ignore wrapper\n                        return undefined;\n                    }\n\n                    if (importPath !== PackageName) {\n                        // Function is not imported from the designated package name -> ignore wrapper\n                        console.warn(`Function ${fnName} is not imported from '${PackageName}' in file ${this.file}`);\n                        return undefined;\n                    }\n\n                    if (exportExpr.arguments.length > 0) {\n                        const firstArg = exportExpr.arguments[0];\n\n                        if (ts.isObjectLiteralExpression(firstArg)) {\n                            for (const prop of firstArg.properties) {\n                                const key = this.objectParser.getName(prop.name ?? prop);\n\n                                if (key !== this.property) continue;\n\n                                if (ts.isPropertyAssignment(prop)) {\n                                    const initType = this.getTypeFromInitializer(prop.initializer);\n                                    if (initType) return initType;\n                                } else if (ts.isMethodDeclaration(prop)) {\n                                    // Get the return type of the method\n                                    const returnType = this.getTypeFromMethodReturn(prop);\n                                    if (returnType) return returnType;\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n\n            const expr = this.unwrapExpression(exportExpr);\n\n            if (ts.isObjectLiteralExpression(expr)) {\n                for (const prop of expr.properties) {\n                    const key = this.objectParser.getName(prop.name ?? prop);\n\n                    if (key !== this.property) continue;\n\n                    if (ts.isPropertyAssignment(prop)) {\n                        return this.getTypeFromInitializer(prop.initializer);\n                    } else if (ts.isMethodDeclaration(prop) || ts.isGetAccessorDeclaration(prop)) {\n                        const sig = this.signatureBuilder.getMethodSignature(prop as ts.MethodDeclaration);\n\n                        return this.signatureBuilder.buildFunctionType(sig);\n                    } else if (ts.isShorthandPropertyAssignment(prop)) {\n                        const name = prop.name.text;\n                        const variable = this.getVariables().get(name);\n\n                        if (variable) {\n                            const val = variable.value;\n                            switch (typeof val) {\n                                case \"string\":\n                                    return \"string\";\n                                case \"number\":\n                                    return \"number\";\n                                case \"boolean\":\n                                    return \"boolean\";\n                                case \"object\":\n                                    if (val === null) return \"null\";\n                                    if (Array.isArray(val)) return \"array\";\n                                    return \"object\";\n                                default:\n                                    return \"any\";\n                            }\n                        }\n                        return \"any\";\n                    }\n                }\n                return undefined;\n            }\n\n            // Fallback: treat default export expression as initializer\n            return this.getTypeFromInitializer(expr);\n        }\n\n        // Default: parse full default export into interface-like string\n        let members: Record<string, MemberSignature> | undefined;\n        const sf = this.getSourceFile();\n\n        const collect = (node: ts.Node) => {\n            if (ts.isExportAssignment(node)) {\n                const expr0 = node.expression;\n                const expr = this.unwrapExpression(expr0);\n                const parsed = this.parse(expr);\n                if (parsed) members = parsed;\n            }\n            ts.forEachChild(node, collect);\n        };\n\n        collect(sf);\n        if (!members) return undefined;\n        return this.signatureBuilder.formatMembers(members);\n    }\n\n    public setProperty(property: string): this {\n        this.property = property;\n\n        return this;\n    }\n\n    /**\n     * Entry point: accepts an expression and returns a map of member signatures,\n     * or undefined if the expression cannot be parsed.\n     */\n    protected parse(expr: ts.Expression): Record<string, MemberSignature> | undefined {\n        if (ts.isFunctionExpression(expr) || ts.isArrowFunction(expr)) {\n            return this.functionParser.parse(expr);\n        } else if (ts.isObjectLiteralExpression(expr)) {\n            return this.objectParser.parse(expr);\n        } else if (ts.isClassExpression(expr)) {\n            return this.classParser.parse(expr);\n        }\n\n        return undefined;\n    }\n\n    /**\n     * Specify wrapper functions whose first argument should be unwrapped for parsing.\n     */\n    public setDefinition(definition: string | string[]): this {\n        const defs = typeof definition === \"string\" ? [definition] : definition;\n\n        defs.forEach(def => this.definition.add(def));\n\n        return this;\n    }\n\n    /**\n     * Recursively unwraps type assertions, satisfies, parentheses, and allowed wrapper calls.\n     */\n    private unwrapExpression(expr: ts.Expression): ts.Expression {\n        // First use the AbstractExpressionParser's unwrapExpression for basic unwrapping\n        expr = this.functionParser.unwrapExpression(expr);\n\n        // Explicitly handle type assertions\n        if (ts.isAsExpression(expr)) {\n            return this.unwrapExpression(expr.expression);\n        }\n\n        // Then handle the additional unwrapping for known definition wrappers\n        if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {\n            const fnName = expr.expression.text;\n\n            if (this.definition.has(fnName)) {\n                let importPath: string | undefined;\n\n                try {\n                    importPath = this.getImports().get(fnName);\n                } catch {\n                    // unable to resolve import source -> ignore wrapper\n                    return expr;\n                }\n\n                if (importPath !== PackageName) {\n                    console.warn(`Function ${fnName} is not imported from '${PackageName}' in file ${this.file}`);\n                } else if (expr.arguments.length > 0) {\n                    const first = expr.arguments[0];\n                    return this.unwrapExpression(first as ts.Expression);\n                }\n            }\n        }\n\n        return expr;\n    }\n\n    /**\n     * Given an initializer or expression, extracts its type: function signature or interface.\n     */\n    private getTypeFromInitializer(\n        node: ts.Expression | ts.MethodDeclaration | ts.GetAccessorDeclaration\n    ): string | undefined {\n        // Unwrap type assertions\n        if (ts.isAsExpression(node)) {\n            return this.getTypeFromInitializer(node.expression);\n        }\n\n        // Function or arrow function: try to parse returned object or instance\n        if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {\n            // attempt to parse returned expression into members\n            const members = this.functionParser.parse(node as ts.FunctionExpression | ts.ArrowFunction);\n\n            if (members) {\n                return this.signatureBuilder.formatMembers(members);\n            }\n\n            // fallback to function signature\n            const sig = this.signatureBuilder.getMethodSignature(node as ts.FunctionExpression | ts.ArrowFunction);\n\n            return this.signatureBuilder.buildFunctionType(sig);\n        }\n\n        // Class or method-like: signature of accessor/method\n        if (ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node)) {\n            const sig = this.signatureBuilder.getMethodSignature(node as ts.MethodDeclaration);\n            return this.signatureBuilder.buildFunctionType(sig);\n        }\n\n        // Object literal, class expression/declaration, or new expression: return interface of members\n        let members: Record<string, MemberSignature> | undefined;\n\n        if (ts.isObjectLiteralExpression(node) || ts.isClassExpression(node) || ts.isClassDeclaration(node)) {\n            members = this.parse(node as ts.Expression);\n        } else if (ts.isNewExpression(node)) {\n            const ctor = node.expression;\n\n            if (ts.isIdentifier(ctor)) {\n                members = this.classParser.parseFileClass(ctor.text);\n            } else if (ts.isClassExpression(ctor)) {\n                members = this.classParser.parse(ctor);\n            }\n        }\n\n        if (members) {\n            return this.signatureBuilder.formatMembers(members);\n        }\n\n        // For literals or other expressions, infer a simple type\n        if (ts.isLiteralExpression(node) || ts.isArrayLiteralExpression(node) || ts.isObjectLiteralExpression(node)) {\n            return this.objectParser.inferTypeFromExpression(node as ts.Expression);\n        }\n\n        // Fallback: undefined\n        return undefined;\n    }\n\n    /**\n     * Extracts the type of the return value of a method, taking into account JSDoc annotations.\n     *\n     * @param method The method declaration to extract the return type from\n     * @returns The extracted return type as a string, or undefined if it cannot be extracted\n     */\n    private getTypeFromMethodReturn(method: ts.MethodDeclaration): string | undefined {\n        // Try to find a return statement in the method body\n        if (method.body) {\n            // First, check if there's a JSDoc return type annotation\n            const jsDocReturnType = this.jsDocParser.getJSDocReturnType(method);\n            if (jsDocReturnType) {\n                // If the return type is a new expression, try to parse it\n                if (jsDocReturnType.includes(\"new \")) {\n                    const className = jsDocReturnType.replace(\"new \", \"\").trim();\n                    const members = this.classParser.parseFileClass(className);\n                    if (members) {\n                        return this.signatureBuilder.formatMembers(members);\n                    }\n                }\n\n                // If the return type is a class name, try to parse it\n                const members = this.classParser.parseFileClass(jsDocReturnType);\n                if (members) {\n                    return this.signatureBuilder.formatMembers(members);\n                }\n\n                return jsDocReturnType;\n            }\n\n            // If there's no JSDoc return type, try to find a return statement\n            let returnExpr: ts.Expression | undefined;\n\n            const findReturn = (node: ts.Node): void => {\n                if (ts.isReturnStatement(node) && node.expression) {\n                    returnExpr = node.expression;\n                    return;\n                }\n                ts.forEachChild(node, findReturn);\n            };\n\n            findReturn(method.body);\n\n            if (returnExpr) {\n                return this.getTypeFromInitializer(returnExpr);\n            }\n        }\n\n        // If we couldn't find a return statement, use the method's return type\n        if (method.type) {\n            return this.typeResolver.resolveTypeNode(method.type);\n        }\n\n        return undefined;\n    }\n}\n"],"mappings":"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","names":["sf","members"]}

package/dist/cli/entrypoint/file/OptionFile.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import EntryFile from './SourceFile.js';
+import './resolvers/ImportResolver.js';
+import './resolvers/TsResolver.js';
+import './types.js';
+
+declare class export_default<T extends Record<string, any>> extends EntryFile {
+    protected definitions: Set<string>;
+    protected definition: string | null | undefined;
+    protected properties: Set<string>;
+    setDefinition(definition: string | string[]): this;
+    setProperties(properties: string[]): this;
+    getOptions(): T;
+    getDefinition(): string | undefined;
+    protected getOptionsFromVariables(): T;
+    protected getOptionsFromDefinition(): T;
+    protected getExpressionForOptions(expr: ts.Expression): ts.Expression | undefined;
+}
+
+export { export_default as default };

package/dist/cli/entrypoint/file/OptionFile.js

@@ -0,0 +1,75 @@
+import ts from "typescript";
+import _ from "lodash";
+import SourceFile from "./SourceFile.js";
+import { PackageName } from "./../../../types/app.js";
+class OptionFile_default extends SourceFile {
+  definitions = /* @__PURE__ */ new Set();
+  definition = void 0;
+  properties = /* @__PURE__ */ new Set();
+  setDefinition(definition) {
+    if (_.isString(definition)) {
+      definition = [definition];
+    }
+    definition.forEach((definition2) => this.definitions.add(definition2));
+    return this;
+  }
+  setProperties(properties) {
+    properties.forEach((property) => this.properties.add(property));
+    return this;
+  }
+  getOptions() {
+    return { ...this.getOptionsFromVariables(), ...this.getOptionsFromDefinition() };
+  }
+  getDefinition() {
+    if (this.definition === void 0) {
+      this.getOptionsFromDefinition();
+    }
+    if (this.definition === null) {
+      return;
+    }
+    return this.definition;
+  }
+  getOptionsFromVariables() {
+    const options = Array.from(this.getVariables().values()).filter(({ name, exported }) => exported && this.properties.has(name)).reduce((config, { name, value }) => ({ ...config, [name]: value }), {});
+    return options;
+  }
+  getOptionsFromDefinition() {
+    let options = {};
+    const parse = (node) => {
+      if (ts.isExportAssignment(node)) {
+        const expr = this.getExpressionForOptions(node.expression);
+        if (expr) {
+          options = this.parseNode(expr);
+        }
+      }
+      ts.forEachChild(node, parse);
+    };
+    parse(this.getSourceFile());
+    return _.pickBy(options, (_2, key) => this.properties.has(key));
+  }
+  getExpressionForOptions(expr) {
+    this.definition = null;
+    if (ts.isObjectLiteralExpression(expr)) {
+      return expr;
+    } else if ((ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) && ts.isObjectLiteralExpression(expr.expression)) {
+      return expr.expression;
+    } else if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+      const functionName = expr.expression.text;
+      if (this.getImports().get(functionName) !== PackageName) {
+        console.warn(`Function ${functionName} is not imported from '${PackageName}' on file ${this.file}`);
+        return;
+      }
+      if (this.definitions.has(functionName) && expr.arguments.length > 0) {
+        const arg = expr.arguments[0];
+        if (ts.isObjectLiteralExpression(arg)) {
+          this.definition = functionName;
+          return arg;
+        }
+      }
+    }
+  }
+}
+export {
+  OptionFile_default as default
+};
+//# sourceMappingURL=OptionFile.js.map

package/dist/cli/entrypoint/file/OptionFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/entrypoint/file/OptionFile.ts"],"sourcesContent":["import ts from \"typescript\";\nimport _ from \"lodash\";\n\nimport SourceFile from \"./SourceFile\";\n\nimport {PackageName} from \"@typing/app\";\n\nexport default class<T extends Record<string, any>> extends SourceFile {\n    protected definitions = new Set<string>();\n\n    protected definition: string | null | undefined = undefined;\n\n    protected properties = new Set<string>();\n\n    public setDefinition(definition: string | string[]): this {\n        if (_.isString(definition)) {\n            definition = [definition];\n        }\n\n        definition.forEach(definition => this.definitions.add(definition));\n\n        return this;\n    }\n\n    public setProperties(properties: string[]): this {\n        properties.forEach(property => this.properties.add(property));\n\n        return this;\n    }\n\n    public getOptions(): T {\n        return {...this.getOptionsFromVariables(), ...this.getOptionsFromDefinition()};\n    }\n\n    public getDefinition(): string | undefined {\n        if (this.definition === undefined) {\n            this.getOptionsFromDefinition();\n        }\n\n        if (this.definition === null) {\n            return;\n        }\n\n        return this.definition;\n    }\n\n    protected getOptionsFromVariables(): T {\n        const options = Array.from(this.getVariables().values())\n            .filter(({name, exported}) => exported && this.properties.has(name))\n            .reduce((config, {name, value}) => ({...config, [name]: value}), {});\n\n        return options as T;\n    }\n\n    protected getOptionsFromDefinition(): T {\n        let options = {} as T;\n\n        const parse = (node: ts.Node) => {\n            if (ts.isExportAssignment(node)) {\n                const expr = this.getExpressionForOptions(node.expression);\n\n                if (expr) {\n                    options = this.parseNode(expr);\n                }\n            }\n\n            ts.forEachChild(node, parse);\n        };\n\n        parse(this.getSourceFile());\n\n        return _.pickBy(options, (_, key) => this.properties.has(key)) as T;\n    }\n\n    protected getExpressionForOptions(expr: ts.Expression): ts.Expression | undefined {\n        this.definition = null;\n\n        if (ts.isObjectLiteralExpression(expr)) {\n            return expr;\n        } else if (\n            (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) &&\n            ts.isObjectLiteralExpression(expr.expression)\n        ) {\n            return expr.expression;\n        } else if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {\n            const functionName = expr.expression.text;\n\n            if (this.getImports().get(functionName) !== PackageName) {\n                console.warn(`Function ${functionName} is not imported from '${PackageName}' on file ${this.file}`);\n\n                return;\n            }\n\n            if (this.definitions.has(functionName) && expr.arguments.length > 0) {\n                const arg = expr.arguments[0];\n\n                if (ts.isObjectLiteralExpression(arg)) {\n                    this.definition = functionName;\n\n                    return arg;\n                }\n            }\n        }\n    }\n}\n"],"mappings":"AAAA,OAAO,QAAQ;AACf,OAAO,OAAO;AAEd,OAAO,gBAAgB;AAEvB,SAAQ,mBAAkB;AAE1B,MAAO,2BAAqD,WAAW;AAAA,EACzD,cAAc,oBAAI,IAAY;AAAA,EAE9B,aAAwC;AAAA,EAExC,aAAa,oBAAI,IAAY;AAAA,EAEhC,cAAc,YAAqC;AACtD,QAAI,EAAE,SAAS,UAAU,GAAG;AACxB,mBAAa,CAAC,UAAU;AAAA,IAC5B;AAEA,eAAW,QAAQ,CAAAA,gBAAc,KAAK,YAAY,IAAIA,WAAU,CAAC;AAEjE,WAAO;AAAA,EACX;AAAA,EAEO,cAAc,YAA4B;AAC7C,eAAW,QAAQ,cAAY,KAAK,WAAW,IAAI,QAAQ,CAAC;AAE5D,WAAO;AAAA,EACX;AAAA,EAEO,aAAgB;AACnB,WAAO,EAAC,GAAG,KAAK,wBAAwB,GAAG,GAAG,KAAK,yBAAyB,EAAC;AAAA,EACjF;AAAA,EAEO,gBAAoC;AACvC,QAAI,KAAK,eAAe,QAAW;AAC/B,WAAK,yBAAyB;AAAA,IAClC;AAEA,QAAI,KAAK,eAAe,MAAM;AAC1B;AAAA,IACJ;AAEA,WAAO,KAAK;AAAA,EAChB;AAAA,EAEU,0BAA6B;AACnC,UAAM,UAAU,MAAM,KAAK,KAAK,aAAa,EAAE,OAAO,CAAC,EAClD,OAAO,CAAC,EAAC,MAAM,SAAQ,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI,CAAC,EAClE,OAAO,CAAC,QAAQ,EAAC,MAAM,MAAK,OAAO,EAAC,GAAG,QAAQ,CAAC,IAAI,GAAG,MAAK,IAAI,CAAC,CAAC;AAEvE,WAAO;AAAA,EACX;AAAA,EAEU,2BAA8B;AACpC,QAAI,UAAU,CAAC;AAEf,UAAM,QAAQ,CAAC,SAAkB;AAC7B,UAAI,GAAG,mBAAmB,IAAI,GAAG;AAC7B,cAAM,OAAO,KAAK,wBAAwB,KAAK,UAAU;AAEzD,YAAI,MAAM;AACN,oBAAU,KAAK,UAAU,IAAI;AAAA,QACjC;AAAA,MACJ;AAEA,SAAG,aAAa,MAAM,KAAK;AAAA,IAC/B;AAEA,UAAM,KAAK,cAAc,CAAC;AAE1B,WAAO,EAAE,OAAO,SAAS,CAACC,IAAG,QAAQ,KAAK,WAAW,IAAI,GAAG,CAAC;AAAA,EACjE;AAAA,EAEU,wBAAwB,MAAgD;AAC9E,SAAK,aAAa;AAElB,QAAI,GAAG,0BAA0B,IAAI,GAAG;AACpC,aAAO;AAAA,IACX,YACK,GAAG,eAAe,IAAI,KAAK,GAAG,sBAAsB,IAAI,MACzD,GAAG,0BAA0B,KAAK,UAAU,GAC9C;AACE,aAAO,KAAK;AAAA,IAChB,WAAW,GAAG,iBAAiB,IAAI,KAAK,GAAG,aAAa,KAAK,UAAU,GAAG;AACtE,YAAM,eAAe,KAAK,WAAW;AAErC,UAAI,KAAK,WAAW,EAAE,IAAI,YAAY,MAAM,aAAa;AACrD,gBAAQ,KAAK,YAAY,YAAY,0BAA0B,WAAW,aAAa,KAAK,IAAI,EAAE;AAElG;AAAA,MACJ;AAEA,UAAI,KAAK,YAAY,IAAI,YAAY,KAAK,KAAK,UAAU,SAAS,GAAG;AACjE,cAAM,MAAM,KAAK,UAAU,CAAC;AAE5B,YAAI,GAAG,0BAA0B,GAAG,GAAG;AACnC,eAAK,aAAa;AAElB,iBAAO;AAAA,QACX;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;","names":["definition","_"]}