@lowgular/code-graph 0.0.1 → 0.1.1

package/{libs/core/codegular/src/lib → codegular}/string.js

@@ -1,51 +1,5 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var string_exports = {};
-__export(string_exports, {
-  getEndCharacter: () => getEndCharacter,
-  getEndLine: () => getEndLine,
-  getFilePath: () => getFilePath,
-  getInitializerText: () => getInitializerText,
-  getNameAndRange: () => getNameAndRange,
-  getNameByIdentifier: () => getNameByIdentifier,
-  getNameOrThrow: () => getNameOrThrow,
-  getPropertyType: () => getPropertyType,
-  getRange: () => getRange,
-  getStartCharacter: () => getStartCharacter,
-  getStartLine: () => getStartLine,
-  getText: () => getText,
-  getTextOrThrow: () => getTextOrThrow,
-  rangeDistance: () => rangeDistance,
-  throwUndefined: () => throwUndefined
-});
-module.exports = __toCommonJS(string_exports);
-var ts = __toESM(require("typescript"));
-var import_utils = require("./utils.js");
+import * as ts from "typescript";
+import { findChildrenByKind } from "./utils.js";
 const { SyntaxKind } = ts;
 const throwUndefined = (val, message) => {
   if (val === void 0) {
@@ -59,7 +13,7 @@ const getNameByIdentifier = (n) => {
   if (n.kind === SyntaxKind.Identifier) {
     return getText(n);
   }
-  const [nameNode] = (0, import_utils.findChildrenByKind)(n, SyntaxKind.Identifier);
+  const [nameNode] = findChildrenByKind(n, SyntaxKind.Identifier);
   return nameNode ? getText(nameNode) : void 0;
 };
 const getInitializerText = (node) => {
@@ -138,7 +92,7 @@ function rangeDistance(outer, inner) {
   return startDistance + endDistance;
 }
 const getNameAndRange = (n) => {
-  const [nameNode] = (0, import_utils.findChildrenByKind)(n, SyntaxKind.Identifier);
+  const [nameNode] = findChildrenByKind(n, SyntaxKind.Identifier);
   if (!nameNode) {
     return void 0;
   }
@@ -148,8 +102,7 @@ const getNameAndRange = (n) => {
   };
 };
 const getNameOrThrow = (n) => throwUndefined(getNameByIdentifier(n), `Could not get name`);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   getEndCharacter,
   getEndLine,
   getFilePath,
@@ -165,4 +118,4 @@ const getNameOrThrow = (n) => throwUndefined(getNameByIdentifier(n), `Could not
   getTextOrThrow,
   rangeDistance,
   throwUndefined
-});
+};

package/{libs/core/codegular/src/lib → codegular}/type-checker.js

@@ -1,40 +1,4 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var type_checker_exports = {};
-__export(type_checker_exports, {
-  getDeclarationFromType: () => getDeclarationFromType,
-  getDeclarationFromTypeLocation: () => getDeclarationFromTypeLocation,
-  getDeclarationFromTypeReference: () => getDeclarationFromTypeReference,
-  getDeclarationFromValueSymbol: () => getDeclarationFromValueSymbol,
-  getDeclarations: () => getDeclarations
-});
-module.exports = __toCommonJS(type_checker_exports);
-var ts = __toESM(require("typescript"));
+import * as ts from "typescript";
 const getDeclarationFromSymbol = (symbol, context) => {
   let aliasedSymbol = symbol;
   try {
@@ -160,11 +124,10 @@ const getDeclarations = (node, typeChecker) => {
   }
   return declarations;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   getDeclarationFromType,
   getDeclarationFromTypeLocation,
   getDeclarationFromTypeReference,
   getDeclarationFromValueSymbol,
   getDeclarations
-});
+};

package/codegular/type.js

@@ -0,0 +1,356 @@
+import * as ts from "typescript";
+import { getDeclarationFromType } from "./type-checker";
+var TypeInfoAbstraction = /* @__PURE__ */ ((TypeInfoAbstraction2) => {
+  TypeInfoAbstraction2["VOID"] = "VoidType";
+  TypeInfoAbstraction2["NULLISH"] = "NullishType";
+  TypeInfoAbstraction2["PRIMITIVE"] = "PrimitiveType";
+  TypeInfoAbstraction2["OBJECT"] = "ObjectType";
+  TypeInfoAbstraction2["FUNCTION"] = "FunctionType";
+  TypeInfoAbstraction2["DECLARATION"] = "DeclarationType";
+  TypeInfoAbstraction2["UNKNOWN"] = "unknown";
+  return TypeInfoAbstraction2;
+})(TypeInfoAbstraction || {});
+const resolveFromType = (type, typeChecker) => {
+  if (type.flags & ts.TypeFlags.Void) {
+    return {
+      abstraction: "VoidType" /* VOID */,
+      declaration: void 0
+    };
+  }
+  if (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) {
+    return {
+      abstraction: "NullishType" /* NULLISH */,
+      declaration: void 0
+    };
+  }
+  if (type.flags & (ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.Boolean | ts.TypeFlags.BigInt | ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol | ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral | ts.TypeFlags.BigIntLiteral)) {
+    return {
+      abstraction: "PrimitiveType" /* PRIMITIVE */,
+      declaration: void 0
+    };
+  }
+  const declaration = getDeclarationFromType(type, {
+    typeChecker
+  });
+  if (declaration) {
+    if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
+      return {
+        abstraction: "DeclarationType" /* DECLARATION */,
+        declaration
+      };
+    }
+  }
+  if (type.getCallSignatures().length > 0) {
+    return {
+      abstraction: "FunctionType" /* FUNCTION */,
+      declaration: void 0
+    };
+  }
+  if (type.flags & ts.TypeFlags.Object) {
+    return {
+      abstraction: "ObjectType" /* OBJECT */,
+      declaration: void 0
+    };
+  }
+  return {
+    abstraction: "unknown" /* UNKNOWN */,
+    declaration: void 0
+  };
+};
+class TypeResolutionTracker {
+  constructor() {
+    // Cache for resolved types - maps ts.Type to TypeInfoImpl
+    this._typeCache = /* @__PURE__ */ new WeakMap();
+    // Cache for resolved types from nodes - maps ts.Node to TypeInfoImpl
+    this._nodeCache = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * Gets the cached TypeInfoImpl for a type, or undefined if not cached.
+   */
+  get(type) {
+    return this._typeCache.get(type);
+  }
+  /**
+   * Caches a TypeInfoImpl for a type.
+   */
+  set(type, value) {
+    this._typeCache.set(type, value);
+  }
+  /**
+   * Gets the cached TypeInfoImpl for a node, or undefined if not cached.
+   */
+  getFromNode(node) {
+    return this._nodeCache.get(node);
+  }
+  /**
+   * Caches a TypeInfoImpl for a node.
+   */
+  setFromNode(node, value) {
+    this._nodeCache.set(node, value);
+  }
+}
+const cacheDecorator = (cb, node, typeResolutionTracker) => {
+  const cached = typeResolutionTracker.getFromNode(node);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const result = cb(node);
+  if (result) {
+    typeResolutionTracker.setFromNode(node, result);
+  }
+  return result;
+};
+const getType = (node, typeChecker, typeResolutionTracker) => {
+  const context = {
+    typeChecker,
+    typeResolutionTracker
+  };
+  const typeImpl = cacheDecorator(
+    (node2) => {
+      try {
+        if (ts.isMethodDeclaration(node2)) {
+          return fromMethodReturnType(node2, context);
+        }
+        if (ts.isPropertyDeclaration(node2)) {
+          if (node2.type) {
+            return fromTsNode(node2.type, context);
+          }
+          if (node2.initializer) {
+            return fromPropertyInitializer(node2.initializer, context);
+          }
+          return void 0;
+        }
+        if (ts.isTypeNode(node2)) {
+          return fromExplicitTypeAnnotation(node2, context);
+        }
+        if (ts.isExpression(node2)) {
+          return fromPropertyInitializer(node2, context);
+        }
+        const type = context.typeChecker.getTypeAtLocation(node2);
+        if (!type) {
+          return void 0;
+        }
+        return fromInferredType(type, context);
+      } catch (error) {
+        console.error("error", error);
+        return void 0;
+      }
+    },
+    node,
+    typeResolutionTracker
+  );
+  if (!typeImpl) {
+    return [];
+  }
+  console.log("typeImpl", typeImpl.type.symbol?.name);
+  return [typeImpl.type];
+};
+function fromTsNode(node, context) {
+  return cacheDecorator(
+    (node2) => {
+      try {
+        if (ts.isMethodDeclaration(node2)) {
+          return fromMethodReturnType(node2, context);
+        }
+        if (ts.isPropertyDeclaration(node2)) {
+          if (node2.type) {
+            return fromTsNode(node2.type, context);
+          }
+          if (node2.initializer) {
+            return fromPropertyInitializer(node2.initializer, context);
+          }
+          return void 0;
+        }
+        if (ts.isTypeNode(node2)) {
+          return fromExplicitTypeAnnotation(node2, context);
+        }
+        if (ts.isExpression(node2)) {
+          return fromPropertyInitializer(node2, context);
+        }
+        const type = context.typeChecker.getTypeAtLocation(node2);
+        if (!type) {
+          return void 0;
+        }
+        return fromInferredType(type, context);
+      } catch (error) {
+        console.error("error", error);
+        return void 0;
+      }
+    },
+    node,
+    context.typeResolutionTracker
+  );
+}
+function fromMethodReturnType(methodNode, context) {
+  try {
+    const cached = context.typeResolutionTracker.getFromNode(methodNode);
+    if (cached !== void 0) {
+      return cached;
+    }
+    if (methodNode.type) {
+      const result = fromExplicitTypeAnnotation(methodNode.type, context);
+      if (result) {
+        context.typeResolutionTracker.setFromNode(methodNode, result);
+      }
+      return result;
+    }
+    const methodType = context.typeChecker.getTypeAtLocation(methodNode);
+    const signatures = methodType.getCallSignatures();
+    if (signatures.length > 0) {
+      const returnType = signatures[signatures.length - 1].getReturnType();
+      if (returnType.symbol) {
+        const result2 = fromTypeWithSymbol(returnType, context);
+        if (result2) {
+          context.typeResolutionTracker.setFromNode(methodNode, result2);
+        }
+        return result2;
+      }
+      const result = fromInferredType(returnType, context);
+      if (result) {
+        context.typeResolutionTracker.setFromNode(methodNode, result);
+      }
+      return result;
+    }
+    return void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+function fromPropertyInitializer(initializer, context) {
+  try {
+    const cached = context.typeResolutionTracker.getFromNode(
+      initializer
+    );
+    if (cached !== void 0) {
+      return cached;
+    }
+    if (ts.isIdentifier(initializer)) {
+      const symbol = context.typeChecker.getSymbolAtLocation(initializer);
+      if (symbol) {
+        const declarations = symbol.getDeclarations();
+        const varDecl = declarations?.find((d) => ts.isVariableDeclaration(d));
+        if (varDecl) {
+          const varType = varDecl.initializer ? context.typeChecker.getTypeAtLocation(varDecl.initializer) : context.typeChecker.getTypeAtLocation(varDecl);
+          if (varType) {
+            const result2 = fromInferredType(varType, context);
+            if (result2) {
+              context.typeResolutionTracker.setFromNode(initializer, result2);
+            }
+            return result2;
+          }
+        }
+      }
+    }
+    const type = context.typeChecker.getTypeAtLocation(initializer);
+    if (!type) {
+      return void 0;
+    }
+    const result = fromInferredType(type, context);
+    if (result) {
+      context.typeResolutionTracker.setFromNode(initializer, result);
+    }
+    return result;
+  } catch (error) {
+    return void 0;
+  }
+}
+function fromTypeWithSymbol(type, context) {
+  try {
+    const cached = context.typeResolutionTracker.get(type);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const baseType = type.target || type;
+    const typeSymbol = baseType.symbol;
+    if (typeSymbol) {
+      const declarations = typeSymbol.getDeclarations();
+      const declaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : typeSymbol.valueDeclaration;
+      if (declaration) {
+        if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
+          return new TypeImplementation(
+            type,
+            // TypeInfoAbstraction.DECLARATION,
+            declaration,
+            void 0,
+            context
+          );
+        }
+      }
+    }
+    return void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+function fromInferredType(type, context) {
+  try {
+    const cached = context.typeResolutionTracker.get(type);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const resolved = resolveFromType(type, context.typeChecker);
+    const typeArgs = type.typeArguments;
+    const typeArguments = typeArgs ? typeArgs.map((arg) => fromInferredType(arg, context)).filter((arg) => arg !== void 0) : void 0;
+    const result = new TypeImplementation(
+      type,
+      // resolved.abstraction,
+      resolved.declaration,
+      typeArguments,
+      context
+    );
+    context.typeResolutionTracker.set(type, result);
+    return result;
+  } catch (error) {
+    return void 0;
+  }
+}
+function fromExplicitTypeAnnotation(typeNode, context) {
+  try {
+    if (ts.isTypeReferenceNode(typeNode)) {
+      const declaration = void 0;
+      if (declaration) {
+        if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
+          const underlyingType = context.typeChecker.getTypeAtLocation(typeNode);
+          const typeArgs = underlyingType && underlyingType.typeArguments;
+          const typeArguments = typeArgs ? typeArgs.map((arg) => fromInferredType(arg, context)).filter((arg) => arg !== void 0) : void 0;
+          return new TypeImplementation(
+            underlyingType,
+            // TypeInfoAbstraction.DECLARATION,
+            declaration,
+            typeArguments,
+            context
+          );
+        }
+      }
+    }
+    const type = context.typeChecker.getTypeAtLocation(typeNode);
+    if (!type) {
+      return void 0;
+    }
+    return fromInferredType(type, context);
+  } catch (error) {
+    return void 0;
+  }
+}
+class TypeImplementation {
+  // public readonly typeArgumentAbstraction: TypeInfoAbstraction | undefined;
+  constructor(type, declaration, typeArguments, context) {
+    this.type = type;
+    this.baseTypes = [];
+    this.name = context.typeChecker.typeToString(type);
+    const baseTypes = type.getBaseTypes();
+    if (baseTypes) {
+      this.baseTypes = baseTypes.map((baseType) => {
+        return fromInferredType(baseType, context);
+      });
+    }
+    this.kind = "Type";
+    this.typeArguments = typeArguments;
+  }
+}
+export {
+  TypeInfoAbstraction,
+  TypeResolutionTracker,
+  cacheDecorator,
+  getType
+};

package/{libs/core/codegular/src/lib → codegular}/utils.js

@@ -1,65 +1,53 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  consoleAllChildren: () => consoleAllChildren,
-  escapeValue: () => escapeValue,
-  findChildByIndex: () => findChildByIndex,
-  findChildByName: () => findChildByName,
-  findChildrenByKind: () => findChildrenByKind,
-  findChildrenByKinds: () => findChildrenByKinds,
-  findChildrenByName: () => findChildrenByName,
-  findFirstChildByKind: () => findFirstChildByKind,
-  findFirstChildByKinds: () => findFirstChildByKinds,
-  findTypeDeclarationByName: () => findTypeDeclarationByName,
-  getAllExpressions: () => getAllExpressions,
-  getAncestorByKind: () => getAncestorByKind,
-  getAncestorsBy: () => getAncestorsBy,
-  getAncestorsByKind: () => getAncestorsByKind,
-  getComments: () => getComments,
-  getDescendantByName: () => getDescendantByName,
-  getDescendantsBy: () => getDescendantsBy,
-  getDescendantsByKind: () => getDescendantsByKind,
-  getDescendantsByKinds: () => getDescendantsByKinds,
-  getSolutionSourceFiles: () => getSolutionSourceFiles,
-  parseArrayLiteralExpression: () => parseArrayLiteralExpression,
-  parseObjectLiteralExpression: () => parseObjectLiteralExpression,
-  peelCallTarget: () => peelCallTarget,
-  readSourceFiles: () => readSourceFiles
-});
-module.exports = __toCommonJS(utils_exports);
-var ts = __toESM(require("typescript"));
-var import_string = require("./string");
-const path = require("path");
+import * as path from "path";
+import * as ts from "typescript";
+import { getNameByIdentifier } from "./string.js";
 const { forEachChild, SyntaxKind } = ts;
 function escapeValue(value) {
   return value.replace(/^['"`]+/i, "").replace(/['"`]+$/i, "");
 }
+const parseObjectLiteralString = (objectLiteralString) => {
+  const result = {};
+  if (!objectLiteralString || typeof objectLiteralString !== "string") {
+    return result;
+  }
+  const code = `const _ = ${objectLiteralString}`;
+  const sourceFile = ts.createSourceFile(
+    "temp.ts",
+    code,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const findObjectLiteral = (node) => {
+    if (ts.isObjectLiteralExpression(node)) {
+      return node;
+    }
+    return ts.forEachChild(node, findObjectLiteral);
+  };
+  const objectLiteral = findObjectLiteral(sourceFile);
+  if (!objectLiteral) {
+    return result;
+  }
+  for (const property of objectLiteral.properties) {
+    if (ts.isPropertyAssignment(property)) {
+      let key;
+      if (ts.isIdentifier(property.name)) {
+        key = property.name.text;
+      } else if (ts.isStringLiteral(property.name)) {
+        key = property.name.text;
+      } else if (ts.isComputedPropertyName(property.name)) {
+        key = property.name.getText(sourceFile);
+      } else {
+        continue;
+      }
+      const value = property.initializer.getText(sourceFile);
+      result[key] = value;
+    } else if (ts.isShorthandPropertyAssignment(property)) {
+      const key = property.name.text;
+      result[key] = key;
+    }
+  }
+  return result;
+};
 function findFirstChildByKind(node, kind) {
   let element;
   forEachChild(node, (child) => {
@@ -168,7 +156,7 @@ function getDescendantsByKinds(node, kinds) {
 function getDescendantByName(node, name) {
   return getDescendantsBy(
     node,
-    (node2) => (0, import_string.getNameByIdentifier)(node2) === name
+    (node2) => getNameByIdentifier(node2) === name
   );
 }
 function findFirstChildByKinds(node, kinds) {
@@ -318,8 +306,7 @@ function readSourceFiles(tsConfigPath) {
   );
   return { sourceFiles: getSolutionSourceFiles(program), program };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   consoleAllChildren,
   escapeValue,
   findChildByIndex,
@@ -342,6 +329,7 @@ function readSourceFiles(tsConfigPath) {
   getSolutionSourceFiles,
   parseArrayLiteralExpression,
   parseObjectLiteralExpression,
+  parseObjectLiteralString,
   peelCallTarget,
   readSourceFiles
-});
+};

package/cypher/index.js

@@ -0,0 +1 @@
+export * from "./lib/index.js";

package/{libs/cli/cypher/src → cypher}/lib/executor/condition-evaluator.js

@@ -1,25 +1,3 @@
-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 condition_evaluator_exports = {};
-__export(condition_evaluator_exports, {
-  ConditionEvaluator: () => ConditionEvaluator
-});
-module.exports = __toCommonJS(condition_evaluator_exports);
 class ConditionEvaluator {
   // @TODO: apply where at match level
   /**
@@ -152,7 +130,6 @@ class ConditionEvaluator {
     }
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   ConditionEvaluator
-});
+};