gt 2.14.35 → 2.14.36

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.js

@@ -1,73 +1,46 @@
-import { findMultiplicationNode } from './findMultiplicationNode.js';
+import { findMultiplicationNode } from "./findMultiplicationNode.js";
+//#region src/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.ts
 /**
- * Given a JSX tree, multiply the derived function nodes
- */
-export function multiplyJsxTree(tree) {
-    if (!Array.isArray(tree)) {
-        return multiplyBranches([tree]);
-    }
-    else {
-        // when tree is an array, this is just sibbling elements within the <T>, so we need to treat them as a single branch
-        const wrapperElement = {
-            nodeType: 'element',
-            type: 'T',
-            props: {
-                children: tree,
-            },
-        };
-        // Multiply the wrapper element
-        const multipliedBranches = multiplyBranches([
-            wrapperElement,
-        ]);
-        // Unwrap the branches
-        return multipliedBranches.map((branch) => branch.props.children);
-    }
+* Given a JSX tree, multiply the derived function nodes
+*/
+function multiplyJsxTree(tree) {
+	if (!Array.isArray(tree)) return multiplyBranches([tree]);
+	else return multiplyBranches([{
+		nodeType: "element",
+		type: "T",
+		props: { children: tree }
+	}]).map((branch) => branch.props.children);
 }
 /**
- * Given a list of branches, multiply recursively (DFS)
- * @param branches
- */
+* Given a list of branches, multiply recursively (DFS)
+* @param branches
+*/
 function multiplyBranches(branches) {
-    // Queue of branches to process
-    const branchQueue = branches;
-    // Finalized branches
-    const newBranches = [];
-    // Process branches until exhausted
-    while (branchQueue.length) {
-        // Pop the next branch
-        const branch = branchQueue.shift();
-        // Get closest multiplication node
-        const currentNode = findMultiplicationNode(branch);
-        // No multiplication nodes, just add the branch to the final list
-        if (!currentNode) {
-            newBranches.push(branch);
-            continue;
-        }
-        const { node, parent, key } = currentNode;
-        // Recursive call
-        const subBranches = multiplyBranches(node.branches);
-        // For every sub branch, create a new cloned branch
-        for (const subBranch of subBranches) {
-            // Placeholder for the new branch
-            let newBranch = undefined;
-            // Create a clone of the original with the sub branch swapped in
-            if (parent === undefined || key === undefined) {
-                // This means the subBranch directly replaces the branch itself
-                newBranches.push(subBranch);
-            }
-            else {
-                // Replace the multiplication node with the sub branch
-                if (Array.isArray(parent)) {
-                    parent[Number(key)] = subBranch;
-                }
-                else {
-                    parent[key] = subBranch;
-                }
-                newBranch = structuredClone(branch);
-                // Add the new branch to the list
-                branchQueue.push(newBranch);
-            }
-        }
-    }
-    return newBranches;
+	const branchQueue = branches;
+	const newBranches = [];
+	while (branchQueue.length) {
+		const branch = branchQueue.shift();
+		const currentNode = findMultiplicationNode(branch);
+		if (!currentNode) {
+			newBranches.push(branch);
+			continue;
+		}
+		const { node, parent, key } = currentNode;
+		const subBranches = multiplyBranches(node.branches);
+		for (const subBranch of subBranches) {
+			let newBranch = void 0;
+			if (parent === void 0 || key === void 0) newBranches.push(subBranch);
+			else {
+				if (Array.isArray(parent)) parent[Number(key)] = subBranch;
+				else parent[key] = subBranch;
+				newBranch = structuredClone(branch);
+				branchQueue.push(newBranch);
+			}
+		}
+	}
+	return newBranches;
 }
+//#endregion
+export { multiplyJsxTree };
+
+//# sourceMappingURL=multiplyJsxTree.js.map

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplyJsxTree.js","names":[],"sources":["../../../../../../src/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.ts"],"sourcesContent":["import {\n  MultipliedTree,\n  MultipliedTreeNode,\n  WhitespaceJsxTree,\n  WhitespaceJsxTreeResult,\n  WhitespaceMultiplicationNode,\n} from '../types.js';\nimport { findMultiplicationNode } from './findMultiplicationNode.js';\n\n/**\n * Given a JSX tree, multiply the derived function nodes\n */\nexport function multiplyJsxTree(\n  tree: WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[]\n): MultipliedTreeNode[] {\n  if (!Array.isArray(tree)) {\n    return multiplyBranches([tree]);\n  } else {\n    // when tree is an array, this is just sibbling elements within the <T>, so we need to treat them as a single branch\n    const wrapperElement: WhitespaceJsxTree = {\n      nodeType: 'element',\n      type: 'T',\n      props: {\n        children: tree,\n      },\n    };\n    // Multiply the wrapper element\n    const multipliedBranches = multiplyBranches([\n      wrapperElement,\n    ]) as MultipliedTree[];\n    // Unwrap the branches\n    return multipliedBranches.map((branch) => branch.props!.children!);\n  }\n}\n\n/**\n * Given a list of branches, multiply recursively (DFS)\n * @param branches\n */\nfunction multiplyBranches(\n  branches: WhitespaceMultiplicationNode['branches']\n): MultipliedTreeNode[] {\n  // Queue of branches to process\n  const branchQueue: (\n    | WhitespaceMultiplicationNode['branches'][0]\n    | MultipliedTreeNode\n  )[] = branches;\n\n  // Finalized branches\n  const newBranches: MultipliedTreeNode[] = [];\n\n  // Process branches until exhausted\n  while (branchQueue.length) {\n    // Pop the next branch\n    const branch = branchQueue.shift() as\n      | WhitespaceJsxTreeResult\n      | WhitespaceMultiplicationNode;\n\n    // Get closest multiplication node\n    const currentNode = findMultiplicationNode(branch);\n\n    // No multiplication nodes, just add the branch to the final list\n    if (!currentNode) {\n      newBranches.push(branch as MultipliedTreeNode);\n      continue;\n    }\n    const { node, parent, key } = currentNode;\n\n    // Recursive call\n    const subBranches = multiplyBranches(node.branches);\n\n    // For every sub branch, create a new cloned branch\n    for (const subBranch of subBranches) {\n      // Placeholder for the new branch\n      let newBranch:\n        | MultipliedTreeNode // <--- Final type (this gets popped off the queue)\n        | WhitespaceJsxTreeResult\n        | WhitespaceMultiplicationNode\n        | undefined = undefined;\n\n      // Create a clone of the original with the sub branch swapped in\n      if (parent === undefined || key === undefined) {\n        // This means the subBranch directly replaces the branch itself\n        newBranches.push(subBranch);\n      } else {\n        // Replace the multiplication node with the sub branch\n        if (Array.isArray(parent)) {\n          parent[Number(key)] = subBranch;\n        } else {\n          parent[key] = subBranch;\n        }\n        newBranch = structuredClone(branch);\n        // Add the new branch to the list\n        branchQueue.push(newBranch);\n      }\n    }\n  }\n\n  return newBranches;\n}\n"],"mappings":";;;;;AAYA,SAAgB,gBACd,MACsB;AACtB,KAAI,CAAC,MAAM,QAAQ,KAAK,CACtB,QAAO,iBAAiB,CAAC,KAAK,CAAC;KAe/B,QAJ2B,iBAAiB,CAC1C;EARA,UAAU;EACV,MAAM;EACN,OAAO,EACL,UAAU,MACX;EAIa,CACf,CAEwB,CAAC,KAAK,WAAW,OAAO,MAAO,SAAU;;;;;;AAQtE,SAAS,iBACP,UACsB;CAEtB,MAAM,cAGA;CAGN,MAAM,cAAoC,EAAE;AAG5C,QAAO,YAAY,QAAQ;EAEzB,MAAM,SAAS,YAAY,OAAO;EAKlC,MAAM,cAAc,uBAAuB,OAAO;AAGlD,MAAI,CAAC,aAAa;AAChB,eAAY,KAAK,OAA6B;AAC9C;;EAEF,MAAM,EAAE,MAAM,QAAQ,QAAQ;EAG9B,MAAM,cAAc,iBAAiB,KAAK,SAAS;AAGnD,OAAK,MAAM,aAAa,aAAa;GAEnC,IAAI,YAIY,KAAA;AAGhB,OAAI,WAAW,KAAA,KAAa,QAAQ,KAAA,EAElC,aAAY,KAAK,UAAU;QACtB;AAEL,QAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,OAAO,IAAI,IAAI;QAEtB,QAAO,OAAO;AAEhB,gBAAY,gBAAgB,OAAO;AAEnC,gBAAY,KAAK,UAAU;;;;AAKjC,QAAO"}