@traqula/core 0.0.10 → 0.0.12

package/lib/Transformers.d.ts

@@ -0,0 +1,70 @@
+import type { Node } from './nodeTypings';
+type Safeness = 'safe' | 'unsafe';
+type SafeWrap<Safe extends Safeness, obj extends object> = Safe extends 'safe' ? {
+    [key in keyof obj]: unknown;
+} : obj;
+export declare class TransformerType<Nodes extends Pick<Node, 'type'>> {
+    protected safeObjectVisit(value: unknown, mapper: (some: object) => any): unknown;
+    transformNode<Safe extends 'safe' | 'unsafe' = 'safe'>(curObject: object, nodeCallBacks: {
+        [T in Nodes['type']]?: {
+            transform?: (op: SafeWrap<Safe, Extract<Nodes, {
+                type: T;
+            }>>) => any;
+            continue?: (op: Extract<Nodes, {
+                type: T;
+            }>) => boolean;
+        };
+    }): any;
+    visitNode(curObject: object, nodeCallBacks: {
+        [T in Nodes['type']]?: (op: Extract<Nodes, {
+            type: T;
+        }>) => boolean;
+    }): void;
+}
+export declare class TransformerSubType<Nodes extends Pick<Node, 'type' | 'subType'>> extends TransformerType<Nodes> {
+    transformNodeSpecific<Safe extends 'safe' | 'unsafe' = 'safe'>(curObject: object, nodeCallBacks: {
+        [T in Nodes['type']]?: {
+            transform?: (op: SafeWrap<Safe, Extract<Nodes, {
+                type: T;
+            }>>) => any;
+            continue?: (op: Extract<Nodes, {
+                type: T;
+            }>) => boolean;
+        };
+    }, nodeSpecificCallBacks?: {
+        [Type in Nodes['type']]?: {
+            [SubType in Extract<Nodes, {
+                type: Type;
+                subType: string;
+            }>['subType']]?: {
+                transform?: (op: SafeWrap<Safe, Extract<Nodes, {
+                    type: Type;
+                    subType: SubType;
+                }>>) => any;
+                continue?: (op: Extract<Nodes, {
+                    type: Type;
+                    subType: SubType;
+                }>) => boolean;
+            };
+        };
+    }): any;
+    /**
+     * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+     */
+    visitNodeSpecific(curObject: object, nodeCallBacks: {
+        [T in Nodes['type']]?: (op: Extract<Nodes, {
+            type: T;
+        }>) => boolean | void;
+    }, nodeSpecificCallBacks?: {
+        [Type in Nodes['type']]?: {
+            [Subtype in Extract<Nodes, {
+                type: Type;
+                subType: string;
+            }>['subType']]?: (op: Extract<Nodes, {
+                type: Type;
+                subType: Subtype;
+            }>) => boolean | void;
+        };
+    }): void;
+}
+export {};

package/lib/Transformers.js

@@ -0,0 +1,114 @@
+export class TransformerType {
+    safeObjectVisit(value, mapper) {
+        if (value && typeof value === 'object') {
+            // If you wonder why this is all so hard, this is the reason. We cannot lose the methods of our Array objects
+            if (Array.isArray(value)) {
+                return value.map(x => this.safeObjectVisit(x, mapper));
+            }
+            return mapper(value);
+        }
+        return value;
+    }
+    transformNode(curObject, nodeCallBacks) {
+        let continueCheck;
+        let transformation;
+        const casted = curObject;
+        if (casted.type) {
+            continueCheck = nodeCallBacks[casted.type]?.continue;
+            transformation = nodeCallBacks[casted.type]?.transform;
+        }
+        let shouldContinue = true;
+        if (continueCheck) {
+            shouldContinue = continueCheck(curObject);
+        }
+        if (!shouldContinue) {
+            return curObject;
+        }
+        const copy = { ...curObject };
+        for (const [key, value] of Object.entries(copy)) {
+            copy[key] =
+                this.safeObjectVisit(value, obj => this.transformNode(obj, nodeCallBacks));
+        }
+        if (transformation) {
+            return transformation(copy);
+        }
+        return copy;
+    }
+    visitNode(curObject, nodeCallBacks) {
+        let callback;
+        const casted = curObject;
+        if (casted.type) {
+            callback = nodeCallBacks[casted.type];
+        }
+        let shouldIterate = true;
+        if (callback) {
+            shouldIterate = callback(curObject);
+        }
+        if (shouldIterate) {
+            for (const value of Object.values(curObject)) {
+                this.safeObjectVisit(value, obj => this.visitNode(obj, nodeCallBacks));
+            }
+        }
+    }
+}
+export class TransformerSubType extends TransformerType {
+    // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
+    //   for (const value of Object.values(curObject)) {
+    //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
+    //   }
+    // }
+    transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+        let continueCheck;
+        let transformation;
+        const casted = curObject;
+        if (casted.type && casted.subType) {
+            const specific = nodeSpecificCallBacks[casted.type];
+            if (specific) {
+                continueCheck = specific[casted.subType]?.continue;
+                transformation = specific[casted.subType]?.transform;
+            }
+        }
+        let shouldContinue = true;
+        if (continueCheck) {
+            shouldContinue = continueCheck(curObject);
+        }
+        if (!shouldContinue) {
+            return curObject;
+        }
+        const copy = { ...curObject };
+        for (const [key, value] of Object.entries(copy)) {
+            copy[key] =
+                this.safeObjectVisit(value, obj => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+        }
+        if (transformation) {
+            return transformation(copy);
+        }
+        return copy;
+    }
+    /**
+     * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+     */
+    visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+        let callback;
+        const casted = curObject;
+        if (casted.type && casted.subType) {
+            const specific = nodeSpecificCallBacks[casted.type];
+            if (specific) {
+                callback = specific[casted.subType];
+            }
+        }
+        if (!callback && casted.type) {
+            callback = nodeCallBacks[curObject.type];
+        }
+        let shouldIterate = true;
+        if (callback) {
+            shouldIterate = callback(curObject) ?? true;
+        }
+        if (shouldIterate) {
+            for (const value of Object.values(curObject)) {
+                this.safeObjectVisit(value, obj => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+            }
+        }
+    }
+}
+//# sourceMappingURL=Transformers.js.map

package/lib/Transformers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transformers.js","sourceRoot":"","sources":["Transformers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Node } from './nodeTypings';\n\ntype Safeness = 'safe' | 'unsafe';\ntype SafeWrap<Safe extends Safeness, obj extends object> = Safe extends 'safe' ? {[key in keyof obj]: unknown } : obj;\n\nexport class TransformerType<Nodes extends Pick<Node, 'type'>> {\n  protected safeObjectVisit(value: unknown, mapper: (some: object) => any): unknown {\n    if (value && typeof value === 'object') {\n      // If you wonder why this is all so hard, this is the reason. We cannot lose the methods of our Array objects\n      if (Array.isArray(value)) {\n        return value.map(x => this.safeObjectVisit(x, mapper));\n      }\n      return mapper(value);\n    }\n    return value;\n  }\n\n  public transformNode<Safe extends 'safe' | 'unsafe' = 'safe'>(\n    curObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      transform?: (op: SafeWrap<Safe, Extract<Nodes, { type: T }>>) => any;\n      continue?: (op: Extract<Nodes, { type: T }>) => boolean;\n    }},\n  ): any {\n    let continueCheck: ((node: any) => boolean) | undefined;\n    let transformation: ((node: any) => unknown) | undefined;\n    const casted = <{ type?: Nodes['type'] }>curObject;\n    if (casted.type) {\n      continueCheck = nodeCallBacks[casted.type]?.continue;\n      transformation = nodeCallBacks[casted.type]?.transform;\n    }\n    let shouldContinue = true;\n    if (continueCheck) {\n      shouldContinue = continueCheck(curObject);\n    }\n    if (!shouldContinue) {\n      return curObject;\n    }\n    const copy: { type?: unknown } = { ...curObject };\n    for (const [ key, value ] of Object.entries(copy)) {\n      (<Record<string, unknown>> copy)[key] =\n        this.safeObjectVisit(value, obj => this.transformNode(obj, nodeCallBacks));\n    }\n    if (transformation) {\n      return transformation(copy);\n    }\n    return copy;\n  }\n\n  public visitNode(\n    curObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: (op: Extract<Nodes, { type: T }>) => boolean },\n  ): void {\n    let callback: ((node: any) => boolean) | undefined;\n    const casted = <{ type?: Nodes['type'] }>curObject;\n    if (casted.type) {\n      callback = nodeCallBacks[casted.type];\n    }\n    let shouldIterate = true;\n    if (callback) {\n      shouldIterate = callback(curObject);\n    }\n    if (shouldIterate) {\n      for (const value of Object.values(curObject)) {\n        this.safeObjectVisit(value, obj => this.visitNode(obj, nodeCallBacks));\n      }\n    }\n  }\n}\n\nexport class TransformerSubType<Nodes extends Pick<Node, 'type' | 'subType'>> extends TransformerType<Nodes> {\n  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {\n  //   for (const value of Object.values(curObject)) {\n  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));\n  //   }\n  // }\n\n  public transformNodeSpecific<Safe extends 'safe' | 'unsafe' = 'safe'>(\n    curObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      transform?: (op: SafeWrap<Safe, Extract<Nodes, { type: T }>>) => any;\n      continue?: (op: Extract<Nodes, { type: T }>) => boolean;\n    }},\n    nodeSpecificCallBacks: {[Type in Nodes['type']]?: {\n      [SubType in Extract<Nodes, { type: Type; subType: string }>['subType']]?: {\n        transform?: (op: SafeWrap<Safe, Extract<Nodes, { type: Type; subType: SubType }>>) => any;\n        continue?: (op: Extract<Nodes, { type: Type; subType: SubType }>) => boolean;\n      }}} = {},\n  ): any {\n    let continueCheck: ((node: any) => boolean) | undefined;\n    let transformation: ((node: any) => unknown) | undefined;\n    const casted = <{ type?: Nodes['type']; subType?: string }>curObject;\n    if (casted.type && casted.subType) {\n      const specific = nodeSpecificCallBacks[casted.type];\n      if (specific) {\n        continueCheck = specific[<keyof typeof specific> casted.subType]?.continue;\n        transformation = specific[<keyof typeof specific> casted.subType]?.transform;\n      }\n    }\n    let shouldContinue = true;\n    if (continueCheck) {\n      shouldContinue = continueCheck(curObject);\n    }\n    if (!shouldContinue) {\n      return curObject;\n    }\n    const copy: { type?: unknown } = { ...curObject };\n    for (const [ key, value ] of Object.entries(copy)) {\n      (<Record<string, unknown>> copy)[key] =\n        this.safeObjectVisit(value, obj => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));\n    }\n    if (transformation) {\n      return transformation(copy);\n    }\n    return copy;\n  }\n\n  /**\n   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback\n   */\n  public visitNodeSpecific(\n    curObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: (op: Extract<Nodes, { type: T }>) => boolean | void },\n    nodeSpecificCallBacks: {[Type in Nodes['type']]?:\n      {[Subtype in Extract<Nodes, { type: Type; subType: string }>['subType']]?:\n        (op: Extract<Nodes, { type: Type; subType: Subtype }>) => boolean | void }} = {},\n  ): void {\n    let callback: ((node: any) => boolean | void) | undefined;\n    const casted = <{ type?: Nodes['type']; subType?: string }> curObject;\n    if (casted.type && casted.subType) {\n      const specific = nodeSpecificCallBacks[casted.type];\n      if (specific) {\n        callback = specific[<keyof typeof specific>casted.subType];\n      }\n    }\n    if (!callback && casted.type) {\n      callback = nodeCallBacks[(<{ type: Nodes['type'] }> curObject).type];\n    }\n    let shouldIterate = true;\n    if (callback) {\n      shouldIterate = callback(curObject) ?? true;\n    }\n    if (shouldIterate) {\n      for (const value of Object.values(curObject)) {\n        this.safeObjectVisit(value, obj => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));\n      }\n    }\n  }\n}\n"]}

package/lib/index.cjs

@@ -25,7 +25,8 @@ __export(index_exports, {
   IndirBuilder: () => IndirBuilder,
   LexerBuilder: () => LexerBuilder,
   ParserBuilder: () => ParserBuilder,
-  Transformer: () => Transformer,
+  TransformerSubType: () => TransformerSubType,
+  TransformerType: () => TransformerType,
   createToken: () => createToken2,
   listToIndirectionMap: () => listToIndirectionMap,
   unCapitalize: () => unCapitalize
@@ -10058,58 +10059,115 @@ function createToken2(config) {
   return createToken(config);
 }
 
-// lib/Transformer.ts
-var Transformer = class {
-  transformNode(curObject, searchType, patch) {
-    const copy = { ...curObject };
-    for (const [key, value] of Object.entries(copy)) {
-      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, searchType, patch));
-    }
-    if (copy.type === searchType) {
-      return patch(copy);
+// lib/Transformers.ts
+var TransformerType = class {
+  safeObjectVisit(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectVisit(x, mapper));
+      }
+      return mapper(value);
     }
-    return copy;
+    return value;
   }
-  transformNodeSpecific(curObject, searchType, searchSubType, patch) {
+  transformNode(curObject, nodeCallBacks) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type) {
+      continueCheck = nodeCallBacks[casted.type]?.continue;
+      transformation = nodeCallBacks[casted.type]?.transform;
+    }
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
+    }
+    if (!shouldContinue) {
+      return curObject;
+    }
     const copy = { ...curObject };
     for (const [key, value] of Object.entries(copy)) {
-      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, searchType, searchSubType, patch));
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
     }
-    if (copy.type === searchType && copy.subType === searchSubType) {
-      return patch(copy);
+    if (transformation) {
+      return transformation(copy);
     }
     return copy;
   }
-  visitObjects(curObject, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitObjects(obj, visitor));
+  visitNode(curObject, nodeCallBacks) {
+    let callback;
+    const casted = curObject;
+    if (casted.type) {
+      callback = nodeCallBacks[casted.type];
     }
-  }
-  visitNode(curObject, searchType, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitNode(obj, searchType, visitor));
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject);
     }
-    if (curObject.type === searchType) {
-      visitor(curObject);
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
+      }
     }
   }
-  visitNodeSpecific(curObject, searchType, searchSubType, visitor) {
-    for (const value of Object.values(curObject)) {
-      this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));
+};
+var TransformerSubType = class extends TransformerType {
+  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
+  //   for (const value of Object.values(curObject)) {
+  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
+  //   }
+  // }
+  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let continueCheck;
+    let transformation;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        continueCheck = specific[casted.subType]?.continue;
+        transformation = specific[casted.subType]?.transform;
+      }
     }
-    const cast = curObject;
-    if (cast.type === searchType && cast.subType === searchSubType) {
-      visitor(curObject);
+    let shouldContinue = true;
+    if (continueCheck) {
+      shouldContinue = continueCheck(curObject);
     }
+    if (!shouldContinue) {
+      return curObject;
+    }
+    const copy = { ...curObject };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+    }
+    if (transformation) {
+      return transformation(copy);
+    }
+    return copy;
   }
-  safeObjectVisit(value, mapper) {
-    if (value && typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map((x) => this.safeObjectVisit(x, mapper));
+  /**
+   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+   */
+  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
+    let callback;
+    const casted = curObject;
+    if (casted.type && casted.subType) {
+      const specific = nodeSpecificCallBacks[casted.type];
+      if (specific) {
+        callback = specific[casted.subType];
+      }
+    }
+    if (!callback && casted.type) {
+      callback = nodeCallBacks[curObject.type];
+    }
+    let shouldIterate = true;
+    if (callback) {
+      shouldIterate = callback(curObject) ?? true;
+    }
+    if (shouldIterate) {
+      for (const value of Object.values(curObject)) {
+        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
       }
-      return mapper(value);
     }
-    return value;
   }
 };
 /*! Bundled license information:

package/lib/index.d.ts

@@ -10,4 +10,4 @@ export * from './parser-builder/ruleDefTypes';
 export * from './utils';
 export * from './CoreFactory';
 export * from './nodeTypings';
-export * from './Transformer';
+export * from './Transformers';

package/lib/index.js

@@ -15,5 +15,5 @@ export * from './parser-builder/ruleDefTypes';
 export * from './utils';
 export * from './CoreFactory';
 export * from './nodeTypings';
-export * from './Transformer';
+export * from './Transformers';
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,6BAA6B;AAC7B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,uBAAuB;AACvB,cAAc,8BAA8B,CAAC;AAC7C,wBAAwB;AACxB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,uBAAuB;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC","sourcesContent":["// Export generator builder\nexport * from './generator-builder/builderTypes';\nexport * from './generator-builder/generatorBuilder';\nexport * from './generator-builder/generatorTypes';\n// Export Indirection Builder\nexport * from './indirection-builder/helpers';\nexport * from './indirection-builder/IndirBuilder';\n// Export lexer builder\nexport * from './lexer-builder/LexerBuilder';\n// Export parser builder\nexport * from './parser-builder/builderTypes';\nexport * from './parser-builder/parserBuilder';\nexport * from './parser-builder/ruleDefTypes';\n// Export general types\nexport * from './utils';\nexport * from './CoreFactory';\nexport * from './nodeTypings';\nexport * from './Transformer';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,6BAA6B;AAC7B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,uBAAuB;AACvB,cAAc,8BAA8B,CAAC;AAC7C,wBAAwB;AACxB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,uBAAuB;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC","sourcesContent":["// Export generator builder\nexport * from './generator-builder/builderTypes';\nexport * from './generator-builder/generatorBuilder';\nexport * from './generator-builder/generatorTypes';\n// Export Indirection Builder\nexport * from './indirection-builder/helpers';\nexport * from './indirection-builder/IndirBuilder';\n// Export lexer builder\nexport * from './lexer-builder/LexerBuilder';\n// Export parser builder\nexport * from './parser-builder/builderTypes';\nexport * from './parser-builder/parserBuilder';\nexport * from './parser-builder/ruleDefTypes';\n// Export general types\nexport * from './utils';\nexport * from './CoreFactory';\nexport * from './nodeTypings';\nexport * from './Transformers';\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/core",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Core components of Traqula",
   "lsd:module": true,
   "license": "MIT",
@@ -46,5 +46,5 @@
   "devDependencies": {
     "@chevrotain/types": "^11.0.3"
   },
-  "gitHead": "94b444f4b1a6904fa4e8979f023a119a48ee4a1d"
+  "gitHead": "3517d5a5223c64dc61184b5f603f6d98c12bd166"
 }

package/lib/Transformer.d.ts

@@ -1,26 +0,0 @@
-import type { SubTyped } from './CoreFactory';
-import type { Node } from './nodeTypings';
-type MapNodeTypeToImpls<Nodes extends Node> = {
-    [Node in Nodes as Node['type']]: Node;
-};
-type MapNodeSubTypeToImpls<Nodes extends Node & {
-    subType: string;
-}> = {
-    [Node in Nodes as Node['subType']]: Node;
-};
-export type AlterNodeOutput<RecursiveObject extends object, Input, Out> = {
-    [Key in keyof RecursiveObject]: RecursiveObject[Key] extends object ? (AlterNodeOutput<RecursiveObject[Key], Input, Out> extends Input ? Out : AlterNodeOutput<RecursiveObject[Key], Input, Out>) : RecursiveObject[Key];
-};
-export declare class Transformer<Nodes extends Node, NodeMapping extends MapNodeTypeToImpls<Nodes> & Record<string, unknown> = MapNodeTypeToImpls<Nodes>> {
-    transformNode<Input extends object, TypeFilter extends keyof NodeMapping, Out>(curObject: Input, searchType: TypeFilter, patch: (current: NodeMapping[TypeFilter]) => Out): AlterNodeOutput<Input, NodeMapping[TypeFilter], Out>;
-    transformNodeSpecific<Input extends object, TypeFilter extends keyof NodeMapping, SpecificType extends keyof SpecificNodes, Out, SpecificNodes = NodeMapping[TypeFilter] extends Node & {
-        subType: string;
-    } ? MapNodeSubTypeToImpls<NodeMapping[TypeFilter]> : never>(curObject: Input, searchType: TypeFilter, searchSubType: SpecificType, patch: (current: SpecificNodes[SpecificType]) => Out): AlterNodeOutput<Input, SubTyped<TypeFilter, SpecificType>, Out>;
-    visitObjects(curObject: object, visitor: (current: object) => void): void;
-    visitNode<Input extends object, TypeFilter extends keyof NodeMapping>(curObject: Input, searchType: TypeFilter, visitor: (current: Readonly<NodeMapping[TypeFilter]>) => void): void;
-    visitNodeSpecific<Input extends object, TypeFilter extends keyof NodeMapping, SpecificType extends keyof SpecificNodes, SpecificNodes = NodeMapping[TypeFilter] extends Node & {
-        subType: string;
-    } ? MapNodeSubTypeToImpls<NodeMapping[TypeFilter]> : never>(curObject: Input, searchType: TypeFilter, searchSubType: SpecificType, visitor: (current: Readonly<SpecificNodes[SpecificType]>) => void): void;
-    private safeObjectVisit;
-}
-export {};

package/lib/Transformer.js

@@ -1,57 +0,0 @@
-export class Transformer {
-    transformNode(curObject, searchType, patch) {
-        const copy = { ...curObject };
-        for (const [key, value] of Object.entries(copy)) {
-            copy[key] =
-                this.safeObjectVisit(value, obj => this.transformNode(obj, searchType, patch));
-        }
-        if (copy.type === searchType) {
-            return patch(copy);
-        }
-        return copy;
-    }
-    transformNodeSpecific(curObject, searchType, searchSubType, patch) {
-        const copy = { ...curObject };
-        for (const [key, value] of Object.entries(copy)) {
-            copy[key] =
-                this.safeObjectVisit(value, obj => this.transformNodeSpecific(obj, searchType, searchSubType, patch));
-        }
-        if (copy.type === searchType && copy.subType === searchSubType) {
-            return patch(copy);
-        }
-        return copy;
-    }
-    visitObjects(curObject, visitor) {
-        for (const value of Object.values(curObject)) {
-            this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
-        }
-    }
-    visitNode(curObject, searchType, visitor) {
-        for (const value of Object.values(curObject)) {
-            this.safeObjectVisit(value, obj => this.visitNode(obj, searchType, visitor));
-        }
-        if (curObject.type === searchType) {
-            visitor(curObject);
-        }
-    }
-    visitNodeSpecific(curObject, searchType, searchSubType, visitor) {
-        for (const value of Object.values(curObject)) {
-            this.safeObjectVisit(value, obj => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));
-        }
-        const cast = curObject;
-        if (cast.type === searchType && cast.subType === searchSubType) {
-            visitor(curObject);
-        }
-    }
-    safeObjectVisit(value, mapper) {
-        if (value && typeof value === 'object') {
-            // If you wonder why this is all so hard, this is the reason. We cannot lose the methods of our Array objects
-            if (Array.isArray(value)) {
-                return value.map(x => this.safeObjectVisit(x, mapper));
-            }
-            return mapper(value);
-        }
-        return value;
-    }
-}
-//# sourceMappingURL=Transformer.js.map

package/lib/Transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Transformer.js","sourceRoot":"","sources":["Transformer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SubTyped } from './CoreFactory';\nimport type { Node } from './nodeTypings';\n\ntype MapNodeTypeToImpls<Nodes extends Node> = {[Node in Nodes as Node['type']]: Node };\ntype MapNodeSubTypeToImpls<Nodes extends Node & { subType: string }> = {[Node in Nodes as Node['subType']]: Node };\n\nexport type AlterNodeOutput<RecursiveObject extends object, Input, Out>\n  = {\n    [Key in keyof RecursiveObject]: RecursiveObject[Key] extends object ?\n        (AlterNodeOutput<RecursiveObject[Key], Input, Out> extends Input ?\n          Out : AlterNodeOutput<RecursiveObject[Key], Input, Out>) :\n      RecursiveObject[Key]\n  };\n\nexport class Transformer<\n  Nodes extends Node,\nNodeMapping extends MapNodeTypeToImpls<Nodes> & Record<string, unknown> = MapNodeTypeToImpls<Nodes>,\n> {\n  public transformNode<Input extends object, TypeFilter extends keyof NodeMapping, Out>(\n    curObject: Input,\n    searchType: TypeFilter,\n    patch: (current: NodeMapping[TypeFilter]) => Out,\n  ): AlterNodeOutput<Input, NodeMapping[TypeFilter], Out> {\n    const copy: { type?: unknown } = { ...curObject };\n    for (const [ key, value ] of Object.entries(copy)) {\n      (<Record<string, unknown>> copy)[key] =\n        this.safeObjectVisit(value, obj => this.transformNode(obj, searchType, patch));\n    }\n    if (copy.type === searchType) {\n      return <any> patch(<NodeMapping[TypeFilter]> copy);\n    }\n    return <any> copy;\n  }\n\n  public transformNodeSpecific<\n    Input extends object,\nTypeFilter extends keyof NodeMapping,\nSpecificType extends keyof SpecificNodes,\nOut,\nSpecificNodes = NodeMapping[TypeFilter] extends Node & { subType: string } ?\n  MapNodeSubTypeToImpls<NodeMapping[TypeFilter]> : never,\n>(\n    curObject: Input,\n    searchType: TypeFilter,\n    searchSubType: SpecificType,\n    patch: (current: SpecificNodes[SpecificType]) => Out,\n  ): AlterNodeOutput<Input, SubTyped<TypeFilter, SpecificType>, Out> {\n    const copy: { type?: unknown; subType?: unknown } = { ...curObject };\n    for (const [ key, value ] of Object.entries(copy)) {\n      (<Record<string, unknown>> copy)[key] =\n        this.safeObjectVisit(value, obj => this.transformNodeSpecific(obj, searchType, searchSubType, patch));\n    }\n    if (copy.type === searchType && copy.subType === searchSubType) {\n      return <any> patch(<SpecificNodes[SpecificType]> copy);\n    }\n    return <any> copy;\n  }\n\n  public visitObjects(curObject: object, visitor: (current: object) => void): void {\n    for (const value of Object.values(curObject)) {\n      this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));\n    }\n  }\n\n  public visitNode<Input extends object, TypeFilter extends keyof NodeMapping>(\n    curObject: Input,\n    searchType: TypeFilter,\n    visitor: (current: Readonly<NodeMapping[TypeFilter]>) => void,\n  ): void {\n    for (const value of Object.values(curObject)) {\n      this.safeObjectVisit(value, obj => this.visitNode(obj, searchType, visitor));\n    }\n    if ((<{ type?: unknown }>curObject).type === searchType) {\n      visitor(<NodeMapping[TypeFilter]> curObject);\n    }\n  }\n\n  public visitNodeSpecific<\n    Input extends object,\nTypeFilter extends keyof NodeMapping,\nSpecificType extends keyof SpecificNodes,\nSpecificNodes = NodeMapping[TypeFilter] extends Node & { subType: string } ?\n  MapNodeSubTypeToImpls<NodeMapping[TypeFilter]> : never,\n >(\n    curObject: Input,\n    searchType: TypeFilter,\n    searchSubType: SpecificType,\n    visitor: (current: Readonly<SpecificNodes[SpecificType]>) => void,\n  ): void {\n    for (const value of Object.values(curObject)) {\n      this.safeObjectVisit(value, obj => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));\n    }\n    const cast = <{ type?: unknown; subType?: unknown }>curObject;\n    if (cast.type === searchType && cast.subType === searchSubType) {\n      visitor(<SpecificNodes[SpecificType]> curObject);\n    }\n  }\n\n  private safeObjectVisit(value: unknown, mapper: (some: object) => any): any {\n    if (value && typeof value === 'object') {\n      // If you wonder why this is all so hard, this is the reason. We cannot lose the methods of our Array objects\n      if (Array.isArray(value)) {\n        return value.map(x => this.safeObjectVisit(x, mapper));\n      }\n      return mapper(value);\n    }\n    return value;\n  }\n}\n"]}