@lowgular/code-graph 0.0.1 → 0.1.2

package/libs/cli/typescript/src/lib/members/statements/expressions/expression.abstraction.js

@@ -1,188 +0,0 @@
-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 expression_abstraction_exports = {};
-__export(expression_abstraction_exports, {
-  ExpressionAbstraction: () => ExpressionAbstraction,
-  checkAllExpressionsStrategy: () => checkAllExpressionsStrategy,
-  countExpressionAbstraction: () => countExpressionAbstraction
-});
-module.exports = __toCommonJS(expression_abstraction_exports);
-var import_codegular = require("@core/codegular");
-var import_core = require("../../../core");
-var import_binary_expression = require("./binary-expression.implementation");
-var import_call_expression = require("./call-expression.implementation");
-var import_property_access_expression = require("./property-access-expression.implementation");
-var import_unary_expression = require("./unary-expression.implementation");
-const ts = require("typescript");
-var ExpressionAbstraction = /* @__PURE__ */ ((ExpressionAbstraction2) => {
-  ExpressionAbstraction2["MUTATING"] = "MutatingExpression";
-  ExpressionAbstraction2["NON_MUTATING"] = "NonMutatingExpression";
-  ExpressionAbstraction2["UNKNOWN"] = "UnknownExpression";
-  return ExpressionAbstraction2;
-})(ExpressionAbstraction || {});
-const mutatingKinds = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.PostfixUnaryExpression,
-  ts.SyntaxKind.DeleteExpression
-]);
-const both = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.PrefixUnaryExpression,
-  ts.SyntaxKind.CallExpression,
-  ts.SyntaxKind.BinaryExpression,
-  ts.SyntaxKind.Identifier
-]);
-const nonMutatingKinds = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.PropertyAccessExpression,
-  ts.SyntaxKind.ElementAccessExpression,
-  ts.SyntaxKind.ConditionalExpression,
-  ts.SyntaxKind.AsExpression,
-  ts.SyntaxKind.SatisfiesExpression,
-  ts.SyntaxKind.YieldExpression,
-  ts.SyntaxKind.JsxExpression,
-  ts.SyntaxKind.CommaListExpression,
-  ts.SyntaxKind.ArrayLiteralExpression,
-  ts.SyntaxKind.ObjectLiteralExpression,
-  ts.SyntaxKind.TemplateExpression,
-  ts.SyntaxKind.ParenthesizedExpression,
-  ts.SyntaxKind.ArrowFunction,
-  ts.SyntaxKind.FunctionExpression,
-  ts.SyntaxKind.NewExpression,
-  ts.SyntaxKind.TypeOfExpression,
-  ts.SyntaxKind.VoidExpression,
-  ts.SyntaxKind.AwaitExpression,
-  ts.SyntaxKind.ThisKeyword,
-  ts.SyntaxKind.SuperKeyword,
-  ts.SyntaxKind.TrueKeyword,
-  ts.SyntaxKind.FalseKeyword,
-  ts.SyntaxKind.NullKeyword,
-  ts.SyntaxKind.UndefinedKeyword,
-  ts.SyntaxKind.Identifier,
-  ts.SyntaxKind.SpreadElement,
-  ts.SyntaxKind.NonNullExpression,
-  ts.SyntaxKind.TypeAssertionExpression,
-  ts.SyntaxKind.TaggedTemplateExpression,
-  ts.SyntaxKind.MetaProperty,
-  ts.SyntaxKind.OmittedExpression,
-  // Literal expressions (always non-mutating)
-  ts.SyntaxKind.StringLiteral,
-  ts.SyntaxKind.NumericLiteral,
-  ts.SyntaxKind.RegularExpressionLiteral,
-  ts.SyntaxKind.NoSubstitutionTemplateLiteral
-]);
-const checkAllExpressionsStrategy = (node, context) => {
-  const counts = {
-    ["MutatingExpression" /* MUTATING */]: 0,
-    ["NonMutatingExpression" /* NON_MUTATING */]: 0,
-    ["UnknownExpression" /* UNKNOWN */]: 0
-  };
-  for (const expr of (0, import_codegular.getAllExpressions)(node)) {
-    if (ts.isLiteralExpression(expr)) {
-      counts["NonMutatingExpression" /* NON_MUTATING */]++;
-      continue;
-    }
-    if (nonMutatingKinds.has(expr.kind)) {
-      counts["NonMutatingExpression" /* NON_MUTATING */]++;
-      continue;
-    }
-    if (ts.isCallExpression(expr)) {
-      const abstraction = new import_call_expression.CallExpressionImplementation(
-        expr,
-        context
-      ).abstraction;
-      counts[abstraction]++;
-      continue;
-    }
-    if (ts.isBinaryExpression(expr)) {
-      const abstraction = new import_binary_expression.BinaryExpressionImplementation(
-        expr,
-        context
-      ).abstraction;
-      counts[abstraction]++;
-      continue;
-    }
-    if (ts.isPrefixUnaryExpression(expr) || ts.isPostfixUnaryExpression(expr) || ts.isDeleteExpression(expr)) {
-      const abstraction = new import_unary_expression.UnaryExpressionImplementation(
-        expr,
-        context
-      ).abstraction;
-      counts[abstraction]++;
-      continue;
-    }
-    if (ts.isPropertyAccessExpression(expr)) {
-      const abstraction = new import_property_access_expression.PropertyAccessExpressionImplementation(
-        expr,
-        context
-      ).abstraction;
-      counts[abstraction]++;
-      continue;
-    }
-    console.error((0, import_codegular.getText)(expr));
-    throw new Error(`Unknown expression type: ${(0, import_core.getSyntaxKindName)(expr.kind)}`);
-  }
-  return counts;
-};
-const checkSpecificExpressionsStrategy = (node, context) => {
-  const counts = {
-    ["MutatingExpression" /* MUTATING */]: 0,
-    ["NonMutatingExpression" /* NON_MUTATING */]: 0,
-    ["UnknownExpression" /* UNKNOWN */]: 0
-  };
-  (0, import_codegular.getDescendantsByKinds)(node, [...mutatingKinds]).forEach((expr) => {
-    counts["MutatingExpression" /* MUTATING */]++;
-  });
-  (0, import_codegular.getDescendantsByKinds)(node, [...nonMutatingKinds]).forEach((expr) => {
-    counts["NonMutatingExpression" /* NON_MUTATING */]++;
-  });
-  const bothExpressions = (0, import_codegular.getDescendantsByKinds)(node, [...both]);
-  for (const expr of bothExpressions) {
-    if (ts.isCallExpression(expr)) {
-      const impl = new import_call_expression.CallExpressionImplementation(
-        expr,
-        context
-      );
-      counts[impl.abstraction]++;
-    } else if (ts.isBinaryExpression(expr)) {
-      const impl = new import_binary_expression.BinaryExpressionImplementation(
-        expr,
-        context
-      );
-      counts[impl.abstraction]++;
-    } else if (ts.isPrefixUnaryExpression(expr) || ts.isPostfixUnaryExpression(expr) || ts.isDeleteExpression(expr)) {
-      const impl = new import_unary_expression.UnaryExpressionImplementation(
-        expr,
-        context
-      );
-      counts[impl.abstraction]++;
-    }
-  }
-  return counts;
-};
-const countExpressionAbstraction = (node, context, strategy = "specific") => {
-  if (strategy === "all") {
-    return checkAllExpressionsStrategy(node, context);
-  }
-  if (strategy === "specific") {
-    return checkSpecificExpressionsStrategy(node, context);
-  }
-  throw new Error(`Invalid strategy: ${strategy}`);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ExpressionAbstraction,
-  checkAllExpressionsStrategy,
-  countExpressionAbstraction
-});

package/libs/cli/typescript/src/lib/members/statements/expressions/property-access-expression.implementation.js

@@ -1,35 +0,0 @@
-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 property_access_expression_implementation_exports = {};
-__export(property_access_expression_implementation_exports, {
-  PropertyAccessExpressionImplementation: () => PropertyAccessExpressionImplementation
-});
-module.exports = __toCommonJS(property_access_expression_implementation_exports);
-var import_core = require("../../../core");
-var import_expression = require("./expression.abstraction");
-const ts = require("typescript");
-class PropertyAccessExpressionImplementation extends import_core.NodableImpl {
-  constructor(node, context) {
-    super(node);
-    this.abstraction = import_expression.ExpressionAbstraction.NON_MUTATING;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PropertyAccessExpressionImplementation
-});

package/libs/cli/typescript/src/lib/members/statements/expressions/unary-expression.implementation.js

@@ -1,51 +0,0 @@
-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 unary_expression_implementation_exports = {};
-__export(unary_expression_implementation_exports, {
-  UnaryExpressionImplementation: () => UnaryExpressionImplementation
-});
-module.exports = __toCommonJS(unary_expression_implementation_exports);
-var import_core = require("../../../core");
-var import_expression = require("./expression.abstraction");
-const ts = require("typescript");
-class UnaryExpressionImplementation extends import_core.NodableImpl {
-  constructor(node, context) {
-    super(node);
-    if (this.isMutating(node)) {
-      this.abstraction = import_expression.ExpressionAbstraction.MUTATING;
-    } else {
-      this.abstraction = import_expression.ExpressionAbstraction.NON_MUTATING;
-    }
-  }
-  isMutating(node) {
-    if (node.kind === ts.SyntaxKind.DeleteExpression) {
-      return true;
-    }
-    if (ts.isPrefixUnaryExpression(node)) {
-      return node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken;
-    }
-    if (ts.isPostfixUnaryExpression(node)) {
-      return node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken;
-    }
-    return false;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  UnaryExpressionImplementation
-});

package/libs/cli/typescript/src/lib/members/statements/statement.implementation.js

@@ -1,49 +0,0 @@
-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 statement_implementation_exports = {};
-__export(statement_implementation_exports, {
-  ReturnStatementImplementation: () => ReturnStatementImplementation
-});
-module.exports = __toCommonJS(statement_implementation_exports);
-var import_codegular = require("@core/codegular");
-var ts = __toESM(require("typescript"));
-var import_core = require("../../core");
-var import_call_expression = require("./expressions/call-expression.implementation");
-class ReturnStatementImplementation extends import_core.NodableImpl {
-  constructor(node, context) {
-    super(node);
-    this.callExpressions = (0, import_codegular.getDescendantsByKind)(
-      node,
-      ts.SyntaxKind.CallExpression
-    ).map((expr) => new import_call_expression.CallExpressionImplementation(expr, context));
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ReturnStatementImplementation
-});

package/libs/cli/typescript/src/lib/members/statements/utils.js

@@ -1,51 +0,0 @@
-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 utils_exports = {};
-__export(utils_exports, {
-  extractTypeName: () => extractTypeName,
-  isMutatorByName: () => isMutatorByName
-});
-module.exports = __toCommonJS(utils_exports);
-const isMutatorByName = (methodName) => {
-  const mutatorPatterns = [
-    /^set[A-Z]/,
-    /^add[A-Z]/,
-    /^remove[A-Z]/,
-    /^delete[A-Z]/,
-    /^update[A-Z]/,
-    /^modify[A-Z]/,
-    /^change[A-Z]/,
-    /^insert[A-Z]/,
-    /^append[A-Z]/,
-    /^push[A-Z]/,
-    /^pop[A-Z]/,
-    /^clear$/,
-    /^reset$/,
-    /^mutate[A-Z]/
-  ];
-  return mutatorPatterns.some((pattern) => pattern.test(methodName));
-};
-const extractTypeName = (typeString) => {
-  const match = typeString.match(/^([A-Z][a-zA-Z0-9]*)/);
-  return match ? match[1] : typeString.split("<")[0].trim();
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  extractTypeName,
-  isMutatorByName
-});

package/libs/cli/typescript/src/lib/plugins/built-in.plugin.js

@@ -1,258 +0,0 @@
-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 built_in_plugin_exports = {};
-__export(built_in_plugin_exports, {
-  BuiltInPlugin: () => BuiltInPlugin
-});
-module.exports = __toCommonJS(built_in_plugin_exports);
-var import_codegular = require("@core/codegular");
-var ts = __toESM(require("typescript"));
-var import_declaration = require("../declaration.abstraction");
-var import_method = require("../members/method.util");
-var import_stubs = require("./stubs");
-const BUILT_IN_TYPES = /* @__PURE__ */ new Set(["Array", "Set", "Map", "WeakSet", "WeakMap"]);
-class ArrayImplementation extends import_stubs.StubNameable {
-  constructor() {
-    super("Array", ts.SyntaxKind[ts.SyntaxKind.InterfaceDeclaration]);
-    this.abstraction = import_declaration.DeclarationAbstraction.DATA_STRUCTURE;
-    this.properties = [];
-    const mutatingMethods = [
-      "push",
-      "pop",
-      "shift",
-      "unshift",
-      "splice",
-      "sort",
-      "reverse",
-      "fill",
-      "copyWithin"
-    ].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.COMMAND
-      )
-    );
-    const queryMethods = [
-      // Iteration and transformation
-      "map",
-      "filter",
-      "flat",
-      "flatMap",
-      "forEach",
-      "reduce",
-      "reduceRight",
-      // Search and test
-      "find",
-      "findIndex",
-      "findLast",
-      "findLastIndex",
-      "some",
-      "every",
-      "includes",
-      "indexOf",
-      "lastIndexOf",
-      // Extraction and combination
-      "slice",
-      "concat",
-      "at",
-      // Immutable array methods (ES2023)
-      "toReversed",
-      "toSorted",
-      "toSpliced",
-      "with",
-      // String conversion
-      "join",
-      "toString",
-      "toLocaleString",
-      // Iterators
-      "entries",
-      "keys",
-      "values"
-    ].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.QUERY
-      )
-    );
-    this.methods = [...mutatingMethods, ...queryMethods];
-  }
-}
-class SetImplementation extends import_stubs.StubNameable {
-  constructor() {
-    super("Set", ts.SyntaxKind[ts.SyntaxKind.InterfaceDeclaration]);
-    this.abstraction = import_declaration.DeclarationAbstraction.DATA_STRUCTURE;
-    this.properties = [];
-    const mutatingMethods = ["add", "delete", "clear"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.COMMAND
-      )
-    );
-    const queryMethods = [
-      "has",
-      "forEach",
-      "entries",
-      "keys",
-      "values",
-      "size"
-      // Property accessor, but treated as method
-    ].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.QUERY
-      )
-    );
-    this.methods = [...mutatingMethods, ...queryMethods];
-  }
-}
-class MapImplementation extends import_stubs.StubNameable {
-  constructor() {
-    super("Map", ts.SyntaxKind[ts.SyntaxKind.InterfaceDeclaration]);
-    this.abstraction = import_declaration.DeclarationAbstraction.DATA_STRUCTURE;
-    this.properties = [];
-    const mutatingMethods = ["set", "delete", "clear"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.COMMAND
-      )
-    );
-    const queryMethods = [
-      "get",
-      "has",
-      "forEach",
-      "entries",
-      "keys",
-      "values",
-      "size"
-      // Property accessor, but treated as method
-    ].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.QUERY
-      )
-    );
-    this.methods = [...mutatingMethods, ...queryMethods];
-  }
-}
-class WeakSetImplementation extends import_stubs.StubNameable {
-  constructor() {
-    super("WeakSet", ts.SyntaxKind[ts.SyntaxKind.InterfaceDeclaration]);
-    this.abstraction = import_declaration.DeclarationAbstraction.DATA_STRUCTURE;
-    this.properties = [];
-    const mutatingMethods = ["add", "delete"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.COMMAND
-      )
-    );
-    const queryMethods = ["has"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.QUERY
-      )
-    );
-    this.methods = [...mutatingMethods, ...queryMethods];
-  }
-}
-class WeakMapImplementation extends import_stubs.StubNameable {
-  constructor() {
-    super("WeakMap", ts.SyntaxKind[ts.SyntaxKind.InterfaceDeclaration]);
-    this.abstraction = import_declaration.DeclarationAbstraction.DATA_STRUCTURE;
-    this.properties = [];
-    const mutatingMethods = ["set", "delete"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.COMMAND
-      )
-    );
-    const queryMethods = ["get", "has"].map(
-      (name) => new import_stubs.StubMethodSignature(
-        name,
-        void 0,
-        [],
-        import_method.MethodImplementationAbstraction.QUERY
-      )
-    );
-    this.methods = [...mutatingMethods, ...queryMethods];
-  }
-}
-class BuiltInPlugin {
-  matches(declaration, context) {
-    const sourceFile = declaration.getSourceFile();
-    const fileName = sourceFile.fileName;
-    const isLibFilePattern = /lib\.[\w]+\.d\.ts$/.test(fileName);
-    const isInTypeScriptLib = fileName.includes("typescript/lib/lib.") || fileName.includes("typescript\\lib\\lib.");
-    if (isLibFilePattern || isInTypeScriptLib) {
-      return true;
-    }
-    const declarationName = (0, import_codegular.getNameByIdentifier)(declaration);
-    return declarationName ? BUILT_IN_TYPES.has(declarationName) : false;
-  }
-  resolve(declaration, context) {
-    const declarationName = (0, import_codegular.getNameByIdentifier)(declaration);
-    if (!declarationName) {
-      return void 0;
-    }
-    switch (declarationName) {
-      case "Array":
-        return new ArrayImplementation();
-      case "Set":
-        return new SetImplementation();
-      case "Map":
-        return new MapImplementation();
-      case "WeakSet":
-        return new WeakSetImplementation();
-      case "WeakMap":
-        return new WeakMapImplementation();
-      default:
-        return void 0;
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BuiltInPlugin
-});

package/libs/cli/typescript/src/lib/plugins/plugin.interface.js

@@ -1,15 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 plugin_interface_exports = {};
-module.exports = __toCommonJS(plugin_interface_exports);