@traqula/core 0.0.21 → 0.0.22

package/dist/cjs/lib/transformers/TransformerObject.js

@@ -0,0 +1,213 @@
+"use strict";
+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 TransformerObject_exports = {};
+__export(TransformerObject_exports, {
+  TransformerObject: () => TransformerObject
+});
+module.exports = __toCommonJS(TransformerObject_exports);
+class TransformerObject {
+  defaultContext;
+  maxStackSize = 1e6;
+  /**
+   * Creates stateless transformer.
+   * @param defaultContext
+   */
+  constructor(defaultContext = {}) {
+    this.defaultContext = defaultContext;
+  }
+  clone(newDefaultContext = {}) {
+    return new TransformerObject({ ...this.defaultContext, ...newDefaultContext });
+  }
+  /**
+   * Function to shallow clone any type.
+   * @param obj
+   * @protected
+   */
+  cloneObj(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto === Object.prototype || proto === null) {
+      return { ...obj };
+    }
+    return Object.assign(Object.create(proto), obj);
+  }
+  /**
+   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
+   * @param startObject object to start iterating from
+   * @param mapper mapper to transform the various objects - argument is a copy of the original
+   * @param preVisitor callback that is evaluated before iterating deeper.
+   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
+   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
+   *    - Default false
+   */
+  transformObject(startObject, mapper, preVisitor = () => ({})) {
+    const defaults = this.defaultContext;
+    const defaultCopyFlag = defaults.copy ?? true;
+    const defaultContinues = defaults.continue ?? true;
+    const defaultIgnoreKeys = defaults.ignoreKeys;
+    const defaultShallowKeys = defaults.shallowKeys;
+    const defaultDidShortCut = defaults.shortcut ?? false;
+    let didShortCut = false;
+    const resultWrap = { res: startObject };
+    const stack = [startObject];
+    const stackParent = [resultWrap];
+    const stackParentKey = ["res"];
+    const handleMapperOnLen = [];
+    const mapperCopyStack = [];
+    const mapperOrigStack = [];
+    const mapperParent = [];
+    const mapperParentKey = [];
+    function handleMapper() {
+      while (stack.length === handleMapperOnLen.at(-1)) {
+        handleMapperOnLen.pop();
+        const copyToMap = mapperCopyStack.pop();
+        const origToMap = mapperOrigStack.pop();
+        const parent = mapperParent.pop();
+        const parentKey = mapperParentKey.pop();
+        parent[parentKey] = mapper(copyToMap, origToMap);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      const curParent = stackParent.pop();
+      const curKey = stackParentKey.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          const newArr = [...curObject];
+          handleMapperOnLen.push(stack.length);
+          mapperCopyStack.push(newArr);
+          mapperOrigStack.push(curObject);
+          mapperParent.push(curParent);
+          mapperParentKey.push(curKey);
+          for (let index = curObject.length - 1; index >= 0; index--) {
+            const val = curObject[index];
+            if (val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParent.push(newArr);
+              stackParentKey.push(index.toString());
+            }
+          }
+          handleMapper();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        const copyFlag = context.copy ?? defaultCopyFlag;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        const shallowKeys = context.shallowKeys ?? defaultShallowKeys;
+        didShortCut = context.shortcut ?? defaultDidShortCut;
+        const copy = copyFlag ? this.cloneObj(curObject) : curObject;
+        handleMapperOnLen.push(stack.length);
+        mapperCopyStack.push(copy);
+        mapperOrigStack.push(curObject);
+        mapperParent.push(curParent);
+        mapperParentKey.push(curKey);
+        if (continues && !didShortCut) {
+          for (const key in copy) {
+            if (!Object.hasOwn(copy, key)) {
+              continue;
+            }
+            const val = copy[key];
+            const onlyShallow = shallowKeys && shallowKeys?.has(key);
+            if (onlyShallow) {
+              copy[key] = this.cloneObj(val);
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            if (!onlyShallow && val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParentKey.push(key);
+              stackParent.push(copy);
+            }
+          }
+        }
+      }
+      handleMapper();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleMapper();
+    return resultWrap.res;
+  }
+  /**
+   * Visitor that visits all objects. Visits deeper objects first.
+   */
+  visitObject(startObject, visitor, preVisitor = () => ({})) {
+    const defaults = this.defaultContext;
+    const defaultContinues = defaults.continue ?? true;
+    const defaultIgnoreKeys = defaults.ignoreKeys;
+    const defaultShortcut = defaults.shortcut ?? false;
+    let didShortCut = false;
+    const stack = [startObject];
+    const handleVisitorOnLen = [];
+    const visitorStack = [];
+    function handleVisitor() {
+      while (stack.length === handleVisitorOnLen.at(-1)) {
+        handleVisitorOnLen.pop();
+        const toVisit = visitorStack.pop();
+        visitor(toVisit);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          for (let i = curObject.length - 1; i >= 0; i--) {
+            stack.push(curObject[i]);
+          }
+          handleVisitor();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        didShortCut = context.shortcut ?? defaultShortcut;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        handleVisitorOnLen.push(stack.length);
+        visitorStack.push(curObject);
+        if (continues && !didShortCut) {
+          for (const key in curObject) {
+            if (!Object.hasOwn(curObject, key)) {
+              continue;
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            const val = curObject[key];
+            if (val && typeof val === "object") {
+              stack.push(val);
+            }
+          }
+        }
+      }
+      handleVisitor();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleVisitor();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformerObject
+});

package/dist/cjs/lib/transformers/TransformerSubTyped.js

@@ -0,0 +1,144 @@
+"use strict";
+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 TransformerSubTyped_exports = {};
+__export(TransformerSubTyped_exports, {
+  TransformerSubTyped: () => TransformerSubTyped
+});
+module.exports = __toCommonJS(TransformerSubTyped_exports);
+var import_TransformerTyped = require("./TransformerTyped.js");
+class TransformerSubTyped extends import_TransformerTyped.TransformerTyped {
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext, defaultNodePreVisitor);
+  }
+  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+    return new TransformerSubTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+  }
+  /**
+   * Shares the functionality and first two arguments with {@link this.transformNode}.
+   * The third argument allows you to also transform based on the subType of objects.
+   * Note that when a callback for the subtype is provided, the callback for the general type is **NOT** executed.
+   * @param startObject
+   * @param nodeCallBacks
+   * @param nodeSpecificCallBacks
+   */
+  transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const transformWrapper = (copy, orig) => {
+      let ogTransform;
+      const casted = copy;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.transform;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.transform;
+        }
+      }
+      return ogTransform ? ogTransform(casted, orig) : copy;
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : {};
+    };
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
+  }
+  /**
+   * Similar to {@link this.visitNode} but also allows you to match based on the subtype of objects.
+   * When both nodeCallBack and NodeSpecific callBack are matched, will only visit nodeSpecifCallback
+   */
+  visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const visitWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.visitor;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.visitor;
+        }
+      }
+      if (ogTransform) {
+        ogTransform(casted);
+      }
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : {};
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  /**
+   * Similar to {@link this.traverseNodes} but also allows you to match based on the subtype of objects.
+   * @param currentNode
+   * @param traverseNode
+   * @param traverseSubNode
+   */
+  traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      let traverser;
+      const subObj = traverseSubNode[curNode.type];
+      if (subObj) {
+        traverser = subObj[curNode.subType];
+      }
+      if (!traverser) {
+        traverser = traverseNode[curNode.type];
+      }
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformerSubTyped
+});

package/dist/cjs/lib/transformers/TransformerTyped.js

@@ -0,0 +1,123 @@
+"use strict";
+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 TransformerTyped_exports = {};
+__export(TransformerTyped_exports, {
+  TransformerTyped: () => TransformerTyped
+});
+module.exports = __toCommonJS(TransformerTyped_exports);
+var import_TransformerObject = require("./TransformerObject.js");
+class TransformerTyped extends import_TransformerObject.TransformerObject {
+  defaultNodePreVisitor;
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext);
+    this.defaultNodePreVisitor = defaultNodePreVisitor;
+  }
+  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+    return new TransformerTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+  }
+  /**
+   * Transform a single node.
+   * The transformation calls the preVisitor from starting from the startObject.
+   * The preVisitor can dictate whether transformation should be stopped.
+   * Note that stopping the transformation also prevets further copying.
+   * The transformer itself transforms object starting with the deepest one that can be visited.
+   * The transformer callback is performed on a copy of the original.
+   * @param startObject
+   * @param nodeCallBacks
+   */
+  transformNode(startObject, nodeCallBacks) {
+    const transformWrapper = (copy, orig) => {
+      let ogTransform;
+      const casted = copy;
+      if (casted.type) {
+        ogTransform = nodeCallBacks[casted.type]?.transform;
+      }
+      return ogTransform ? ogTransform(casted, orig) : copy;
+    };
+    const nodeDefaults = this.defaultNodePreVisitor;
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      let nodeContext = {};
+      const casted = curObject;
+      if (casted.type) {
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
+      }
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
+    };
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
+  }
+  /**
+   * Similar to {@link this.transformNode}, but without copying the startObject.
+   * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
+   * @param startObject
+   * @param nodeCallBacks
+   */
+  visitNode(startObject, nodeCallBacks) {
+    const visitorWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogTransform = nodeCallBacks[casted.type]?.visitor;
+        if (ogTransform) {
+          ogTransform(casted);
+        }
+      }
+    };
+    const nodeDefaults = this.defaultNodePreVisitor;
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      let nodeContext = {};
+      const casted = curObject;
+      if (casted.type) {
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
+      }
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
+    };
+    return this.visitObject(startObject, visitorWrapper, preVisitWrapper);
+  }
+  /**
+   * Traverses only selected nodes as returned by the function.
+   * @param currentNode
+   * @param traverse
+   */
+  traverseNodes(currentNode, traverse) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      const traverser = traverse[curNode.type];
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformerTyped
+});

package/dist/cjs/lib/types.js

@@ -0,0 +1,16 @@
+"use strict";
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/lib/utils.js

@@ -0,0 +1,39 @@
+"use strict";
+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, {
+  createToken: () => createToken,
+  traqulaIndentation: () => traqulaIndentation,
+  unCapitalize: () => unCapitalize
+});
+module.exports = __toCommonJS(utils_exports);
+var import_chevrotain = require("@traqula/chevrotain");
+function unCapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function createToken(config) {
+  return (0, import_chevrotain.createToken)(config);
+}
+const traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createToken,
+  traqulaIndentation,
+  unCapitalize
+});

package/dist/cjs/test/generatorBuilder/generatorBuilder.types.test.js

@@ -0,0 +1,30 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_lib = require("../../lib/index.js");
+const RuleA = {
+  name: "apple",
+  gImpl: () => () => {
+  }
+};
+const RuleB = {
+  name: "banana",
+  gImpl: () => () => {
+  }
+};
+const RuleC = {
+  name: "coconut",
+  gImpl: () => () => {
+  }
+};
+(0, import_vitest.describe)("parserBuilder", () => {
+  (0, import_vitest.describe)("types", () => {
+    (0, import_vitest.it)("builder constructor", () => {
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleA])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleB])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleA, RuleB])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleA, RuleB]).addRule(RuleC)).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleA]).merge(import_lib.GeneratorBuilder.create([RuleB]), [])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.GeneratorBuilder.create([RuleA, RuleB]).merge(import_lib.GeneratorBuilder.create([RuleB, RuleC]), [])).branded.toEqualTypeOf();
+    });
+  });
+});

package/dist/cjs/test/grammar-builder/parserBuilder.types.test.js

@@ -0,0 +1,27 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_lib = require("../../lib/index.js");
+const RuleA = {
+  name: "apple",
+  impl: () => () => "apple"
+};
+const RuleB = {
+  name: "banana",
+  impl: () => () => "banana"
+};
+const RuleC = {
+  name: "coconut",
+  impl: () => () => "coconut"
+};
+(0, import_vitest.describe)("parserBuilder", () => {
+  (0, import_vitest.describe)("types", () => {
+    (0, import_vitest.it)("builder constructor", () => {
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleA])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleB])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleA, RuleB])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleA, RuleB]).addRule(RuleC)).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleA]).merge(import_lib.ParserBuilder.create([RuleB]), [])).branded.toEqualTypeOf();
+      (0, import_vitest.expectTypeOf)(import_lib.ParserBuilder.create([RuleA, RuleB]).merge(import_lib.ParserBuilder.create([RuleB, RuleC]), [])).branded.toEqualTypeOf();
+    });
+  });
+});

package/dist/cjs/test/transformer.test.js

@@ -0,0 +1,82 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_lib = require("../lib/index.js");
+(0, import_vitest.describe)("transformer", () => {
+  const transformer = new import_lib.TransformerTyped();
+  (0, import_vitest.it)("makes copies when needed", ({ expect }) => {
+    const fruit = {
+      type: "fruit",
+      clone1: { type: "vegetable", random: { type: "fruit", val: "blep" } }
+    };
+    const fullCopy = transformer.transformNode(fruit, {});
+    expect(fullCopy).not.toBe(fruit);
+    expect(fullCopy.clone1).not.toBe(fruit.clone1);
+    expect(fullCopy.clone1.random).not.toBe(fruit.clone1.random);
+    const sameVegetable = transformer.transformNode(fruit, {
+      vegetable: { preVisitor: () => ({ copy: false }) },
+      fruit: { transform: (fruit2) => {
+        fruit2.test = "yes";
+        return fruit2;
+      } }
+    });
+    expect(sameVegetable).not.toBe(fruit);
+    expect(sameVegetable.clone1).toBe(fruit.clone1);
+    expect(sameVegetable.clone1.random).toMatchObject({ test: "yes" });
+  });
+  (0, import_vitest.it)("knows shortcut and continue", ({ expect }) => {
+    const in2 = { type: "fruit", val: "depth3" };
+    const in1 = { type: "vegetable", in: in2, val: "depth2" };
+    const side1 = { type: "fruit", val: "side1" };
+    const side2 = { type: "vegetable" };
+    const fruit = { type: "fruit", in: in1, val: "depth1", side: side1, side2 };
+    const onlyCopyDepth1 = transformer.transformNode(fruit, {
+      fruit: { preVisitor: () => ({ continue: false }) }
+    });
+    expect(onlyCopyDepth1).not.toBe(fruit);
+    expect(onlyCopyDepth1.in).toBe(in1);
+    expect(onlyCopyDepth1.in.in).toBe(in2);
+    expect(onlyCopyDepth1.side).toBe(side1);
+    const doNotCopy = transformer.transformNode(fruit, {
+      fruit: { preVisitor: () => ({ continue: false, copy: false }) }
+    });
+    expect(doNotCopy).toBe(fruit);
+    expect(doNotCopy.in).toBe(in1);
+    expect(doNotCopy.in.in).toBe(in2);
+    expect(doNotCopy.side).toBe(side1);
+    const doNotCopyByShortcut = transformer.transformNode(fruit, {
+      fruit: { preVisitor: () => ({ shortcut: true }) }
+    });
+    expect(doNotCopyByShortcut).not.toBe(fruit);
+    expect(doNotCopyByShortcut.in).toBe(in1);
+    expect(doNotCopyByShortcut.in.in).toBe(in2);
+    expect(doNotCopyByShortcut.side).toBe(side1);
+    const doNotCopySideWhenShortcut = transformer.transformNode(fruit, {
+      vegetable: { preVisitor: () => ({ shortcut: true }) }
+    });
+    expect(doNotCopySideWhenShortcut).not.toBe(fruit);
+    expect(doNotCopySideWhenShortcut.in).toBe(in1);
+    expect(doNotCopySideWhenShortcut.in.in).toBe(in2);
+    expect(doNotCopySideWhenShortcut.side).toBe(side1);
+    expect(doNotCopySideWhenShortcut.side2).not.toBe(side2);
+  });
+  (0, import_vitest.it)("knows shallowKeys and ignoreKeys", ({ expect }) => {
+    const in2 = { type: "fruit", val: "depth3" };
+    const in1 = { type: "vegetable", in: in2, val: "depth2" };
+    const side1 = { type: "fruit", val: "side1" };
+    const fruit = { type: "fruit", in: in1, val: "depth1", side: side1 };
+    const noDeepOnShallowKeys = transformer.transformNode(fruit, {
+      fruit: { preVisitor: () => ({ shallowKeys: /* @__PURE__ */ new Set(["in"]) }) }
+    });
+    expect(noDeepOnShallowKeys).not.toBe(fruit);
+    expect(noDeepOnShallowKeys.in).not.toBe(in1);
+    expect(noDeepOnShallowKeys.in.in).toBe(in2);
+    expect(noDeepOnShallowKeys.side).not.toBe(side1);
+    const ignoreKeysAreIgnored = transformer.transformNode(fruit, {
+      fruit: { preVisitor: () => ({ ignoreKeys: /* @__PURE__ */ new Set(["in"]) }) }
+    });
+    expect(ignoreKeysAreIgnored).not.toBe(fruit);
+    expect(ignoreKeysAreIgnored.in).toBe(in1);
+    expect(ignoreKeysAreIgnored.in.in).toBe(in2);
+    expect(ignoreKeysAreIgnored.side).not.toBe(side1);
+  });
+});