tungsten 0.2.1 → 0.2.3

package/dist/babelPlugins/BabelTransformReactive.d.ts

@@ -0,0 +1,15 @@
+import type { BabelFake } from './BabelFakeType.js';
+import type { NodePath, PluginPass } from '@babel/core';
+import type { CallExpression, MemberExpression } from '@babel/types';
+export default function MakeBabelTransformBind(): (babel: BabelFake) => {
+    name: string;
+    pre(): void;
+    visitor: {
+        CallExpression: {
+            enter(path: NodePath<CallExpression>, state: PluginPass): void;
+            exit(path: NodePath<CallExpression>, state: PluginPass): void;
+        };
+        MemberExpression(path: NodePath<MemberExpression>, state: PluginPass): void;
+    };
+};
+//# sourceMappingURL=BabelTransformReactive.d.ts.map

package/dist/babelPlugins/BabelTransformReactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformReactive.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformReactive.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EAAQ,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAyCpE,MAAM,CAAC,OAAO,UAAU,sBAAsB,KACP,OAAO,SAAS;;;;;wBA0BvB,QAAQ,CAAC,cAAc,CAAC,SAAS,UAAU;uBA+B5C,QAAQ,CAAC,cAAc,CAAC,SAAS,UAAU;;+BA+CnC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,UAAU;;EAsCnF"}

package/dist/babelPlugins/BabelTransformReactive.js

@@ -0,0 +1,128 @@
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+import { throwError } from "../throwError.js";
+/////////////////////////////////////////////////
+// Is this WIP?
+/////////////////////////////////////////////////
+const reactiveFunctionName = 'reactive';
+// type VariablePart = {
+//     property: any, // something in babel
+//     computed: any // something in babel
+// }
+// function getSourceCode(state, node) {
+//     return state.file.code.substring(node.start, node.end)                 
+// }
+function calleeIsThisDotReactive(callee) {
+  return callee.type === 'MemberExpression' && callee.object.type === 'ThisExpression' && callee.property.type === 'Identifier' && callee.property.name === reactiveFunctionName;
+}
+function deDupeDeps(arr) {
+  const unique = [];
+  for (const dependency of arr) {
+    const alreadyPresent = unique.some(existing => existing.length === dependency.length && existing.every((part, index) => part === dependency[index]));
+    if (!alreadyPresent) unique.push(dependency);
+  }
+  return unique;
+}
+export default function MakeBabelTransformBind(/*opts: Opts*/
+) {
+  return function BabelTransformBind(babel) {
+    const t = babel.types;
+    function depsToSyntaxTree(deps) {
+      return deps.map(
+      // d = e.g. ['a', 'b']
+      d => t.arrayExpression(d.map(
+      // s = e.g. 'a'
+      s => t.stringLiteral(s))));
+    }
+    let reactiveIndex;
+    let insideReactive;
+    let reactiveDependencies;
+    return {
+      name: 'ast-transform',
+      // not required
+      pre() {
+        reactiveIndex = 0;
+        insideReactive = 0;
+      },
+      visitor: {
+        CallExpression: {
+          enter(path, state) {
+            const callExpression = path.node;
+            //console.log('found a callEx', callExpression)
+            const callee = callExpression.callee;
+            //console.log('callee', callee)
+            if (calleeIsThisDotReactive(callee)) {
+              const callback = callExpression.arguments[0];
+              if (callback === undefined || callback.type === 'SpreadElement' || callback.type === 'ArgumentPlaceholder') {
+                throwError('BabelTransformReactive', 'this.reactive() must have an expression as its first argument');
+              }
+              // we may need to change this so that we
+              // only process code in the first arg position
+              insideReactive++;
+              if (insideReactive === 1) {
+                // just entered a reactive block
+                reactiveDependencies = [];
+              }
+              //console.log('found this.reactive', insideReactive)
+              //const func = callExpression.arguments[0]
+              //console.log(
+              //console.log('setter func', func)
+              //console.log('state', state)
+              //console.log('node', path.node.left)
+              //console.log('code', getSourceCode(state, path.node.left))
+            }
+          },
+          exit(path, state) {
+            const callExpression = path.node;
+            const callee = callExpression.callee;
+            if (calleeIsThisDotReactive(callee)) {
+              const callback = callExpression.arguments[0];
+              if (callback === undefined || callback.type === 'SpreadElement' || callback.type === 'ArgumentPlaceholder') {
+                throwError('BabelTransformReactive', 'this.reactive() must have an expression as its first argument');
+              }
+              insideReactive--;
+              console.log('exit reactive', insideReactive);
+              console.log('reactiveDependencies', reactiveDependencies);
+              //const depsArray = t.arrayExpression(reactiveDependencies)
+              console.log('dd', deDupeDeps(reactiveDependencies));
+              const depsArray = t.arrayExpression(depsToSyntaxTree(deDupeDeps(reactiveDependencies)));
+              console.log('depsArray', depsArray);
+              path.replaceWith(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__reactive')), [
+              //t.stringLiteral(getSourceCode(state, path.node)),
+              t.numericLiteral(reactiveIndex), callback, depsArray]));
+            }
+            //path.skip()
+          }
+        },
+        MemberExpression(path, state) {
+          if (insideReactive >= 1) {
+            const mE = path.node;
+            if (mE.object.type === 'ThisExpression' && mE.property.type === 'Identifier' && mE.property.name === 'state') {
+              //console.log('found this.state')
+              if (path.parent.type === 'MemberExpression') {
+                //let parentME = path.parent
+                //console.log('parent ME', parentME)
+                const varPath = [];
+                let p = path;
+                while (p.parentPath.isMemberExpression()) {
+                  p = p.parentPath;
+                  const property = p.node.property;
+                  if (property.type !== 'Identifier') {
+                    throwError('BabelTransformReactive', `reactive state dependency properties must be identifiers; received ${property.type}`);
+                  }
+                  varPath.push(property.name);
+                }
+                console.log('varPath', varPath);
+                // de dupe
+                reactiveDependencies.push(varPath);
+                console.log('reactiveDependencies', [...reactiveDependencies]);
+              }
+            }
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformReactiveSvelteStyle.d.ts

@@ -0,0 +1,10 @@
+import type { BabelFake } from './BabelFakeType.js';
+import type { NodePath, PluginPass } from '@babel/core';
+import type { AssignmentExpression } from '@babel/types';
+export default function MakeBabelTransformBind(): (babel: BabelFake) => {
+    name: string;
+    visitor: {
+        AssignmentExpression(path: NodePath<AssignmentExpression>, state: PluginPass): void;
+    };
+};
+//# sourceMappingURL=BabelTransformReactiveSvelteStyle.d.ts.map

package/dist/babelPlugins/BabelTransformReactiveSvelteStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformReactiveSvelteStyle.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformReactiveSvelteStyle.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EAAQ,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAiBxD,MAAM,CAAC,OAAO,UAAU,sBAAsB,KACP,OAAO,SAAS;;;mCAKZ,QAAQ,CAAC,oBAAoB,CAAC,SAAS,UAAU;;EAmC3F"}

package/dist/babelPlugins/BabelTransformReactiveSvelteStyle.js

@@ -0,0 +1,45 @@
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+import { throwError } from "../throwError.js";
+const reactiveFunctionName = 'reactive';
+// type VariablePart = {
+//     property: any, // something in babel
+//     computed: any // something in babel
+// }
+function getSourceCode(state, node) {
+  if (node.start == null || node.end == null) {
+    throwError('BabelTransformReactiveSvelteStyle', `source positions are missing for ${node.type}`);
+  }
+  return state.file.code.substring(node.start, node.end);
+}
+export default function MakeBabelTransformBind(/*opts: Opts*/
+) {
+  return function BabelTransformBind(babel) {
+    const t = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      visitor: {
+        AssignmentExpression(path, state) {
+          if (path.node.right.type === 'CallExpression') {
+            const callExpression = path.node.right;
+            //console.log('found a callEx', callExpression)
+            const callee = callExpression.callee;
+            if (callee.type === 'MemberExpression' && callee.object.type === 'ThisExpression' && callee.property.type === 'Identifier' && callee.property.name === reactiveFunctionName) {
+              //console.log('found this.reactive')
+              //const func = callExpression.arguments[0]
+              //console.log(
+              //console.log('setter func', func)
+              //console.log('state', state)
+              //console.log('node', path.node.left)
+              //console.log('code', getSourceCode(state, path.node.left))
+              path.replaceWith(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('reactive')), [t.stringLiteral(getSourceCode(state, path.node.left)), ...callExpression.arguments]));
+            }
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformRemoveBlocks.d.ts

@@ -0,0 +1,13 @@
+import type { NodePath } from '@babel/core';
+import { ConditionalExpression, IfStatement } from '@babel/types';
+type Opts = {
+    names: string[];
+};
+export declare function MakeBabelTransformRemoveBlocks(opts: Opts): () => {
+    visitor: {
+        IfStatement(path: NodePath<IfStatement>): void;
+        ConditionalExpression(path: NodePath<ConditionalExpression>): void;
+    };
+};
+export {};
+//# sourceMappingURL=BabelTransformRemoveBlocks.d.ts.map

package/dist/babelPlugins/BabelTransformRemoveBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformRemoveBlocks.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformRemoveBlocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAc,qBAAqB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE7E,KAAK,IAAI,GAAG;IACR,KAAK,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,IAAI;;0BAmBvB,QAAQ,CAAC,WAAW,CAAC;oCAWX,QAAQ,CAAC,qBAAqB,CAAC;;EAS1E"}

package/dist/babelPlugins/BabelTransformRemoveBlocks.js

@@ -0,0 +1,38 @@
+export function MakeBabelTransformRemoveBlocks(opts) {
+  return function BabelTransformRemoveBlocks(/*babel*/
+  ) {
+    //const t = babel.types
+    function investigationCondition(test) {
+      if (test.type === 'Identifier' && opts.names.includes(test.name)) {
+        return true;
+      } else if (test.type === 'LogicalExpression' && test.operator === '&&') {
+        return investigationCondition(test.left) || investigationCondition(test.right);
+      } else if (test.type === 'LogicalExpression' && test.operator === '||') {
+        return investigationCondition(test.left) && investigationCondition(test.right);
+      } else {
+        return false;
+      }
+    }
+    //let require
+    return {
+      visitor: {
+        IfStatement(path) {
+          const test = path.node.test;
+          if (investigationCondition(test)) {
+            if (path.node.alternate) {
+              path.replaceWith(path.node.alternate);
+            } else {
+              path.remove();
+            }
+          }
+        },
+        ConditionalExpression(path) {
+          const test = path.node.test;
+          if (investigationCondition(test)) {
+            path.replaceWith(path.node.alternate);
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformRemoveServerBlocks.d.ts

@@ -0,0 +1,9 @@
+import { NodePath } from '@babel/core';
+import type { ConditionalExpression, IfStatement } from '@babel/types';
+export declare function MakeBabelTransformRemoveServerBlocks(): () => {
+    visitor: {
+        IfStatement(path: NodePath<IfStatement>): void;
+        ConditionalExpression(path: NodePath<ConditionalExpression>): void;
+    };
+};
+//# sourceMappingURL=BabelTransformRemoveServerBlocks.d.ts.map

package/dist/babelPlugins/BabelTransformRemoveServerBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformRemoveServerBlocks.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformRemoveServerBlocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,KAAK,EAAE,qBAAqB,EAAc,WAAW,EAAE,MAAM,cAAc,CAAA;AASlF,wBAAgB,oCAAoC;;0BAgBlB,QAAQ,CAAC,WAAW,CAAC;oCAWX,QAAQ,CAAC,qBAAqB,CAAC;;EAS1E"}

package/dist/babelPlugins/BabelTransformRemoveServerBlocks.js

@@ -0,0 +1,40 @@
+//////////////////////////////////////
+//////////////////////////////////////
+// TODO: Remove serverInit functions
+//////////////////////////////////////
+//////////////////////////////////////
+export function MakeBabelTransformRemoveServerBlocks() {
+  return function BabelTransformRemoveServerBlocks(/*babel*/
+  ) {
+    //const t = babel.types
+    function investigationCondition(test) {
+      if (test.type === 'Identifier' && test.name === 'isServer') {
+        return true;
+      } else if (test.type === 'LogicalExpression' && test.operator === '&&') {
+        return investigationCondition(test.left) || investigationCondition(test.right);
+      }
+      return false;
+    }
+    //let require
+    return {
+      visitor: {
+        IfStatement(path) {
+          const test = path.node.test;
+          if (investigationCondition(test)) {
+            if (path.node.alternate) {
+              path.replaceWith(path.node.alternate);
+            } else {
+              path.remove();
+            }
+          }
+        },
+        ConditionalExpression(path) {
+          const test = path.node.test;
+          if (investigationCondition(test)) {
+            path.replaceWith(path.node.alternate);
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformRemoveServerCode.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BabelTransformRemoveServerCode.d.ts.map

package/dist/babelPlugins/BabelTransformRemoveServerCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformRemoveServerCode.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformRemoveServerCode.ts"],"names":[],"mappings":""}

package/dist/babelPlugins/BabelTransformRemoveServerCode.js

@@ -0,0 +1 @@
+export {};

package/dist/babelPlugins/BabelTransformSxyFrameworkImports.d.ts

@@ -0,0 +1,8 @@
+import type { NodePath } from '@babel/core';
+import { ImportDeclaration } from '@babel/types';
+export declare function MakeBabelTransformTungstenFrameworkImports(): () => {
+    visitor: {
+        ImportDeclaration: (path: NodePath<ImportDeclaration>) => void;
+    };
+};
+//# sourceMappingURL=BabelTransformSxyFrameworkImports.d.ts.map

package/dist/babelPlugins/BabelTransformSxyFrameworkImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformSxyFrameworkImports.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformSxyFrameworkImports.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAKhD,wBAAgB,0CAA0C;;kCAKP,QAAQ,CAAC,iBAAiB,CAAC;;EAW7E"}

package/dist/babelPlugins/BabelTransformSxyFrameworkImports.js

@@ -0,0 +1,27 @@
+// BabelTransformSxyFrameworkImports
+// exports MakeBabelTransformSxyFrameworkImports (function)
+//
+// Seems to convert imports of 'tungsten' to import from the 
+// compiled tungsten packages in <buildLocation>/<packagesFolder>
+// but not sure this is working/in use
+import { packagesFolder } from "../settings.js";
+// type Opts = {
+// }
+export function MakeBabelTransformTungstenFrameworkImports(/*opts: Opts*/
+) {
+  return function BabelTransformTungstenFrameworkImports(/*babel*/
+  ) {
+    //const t = babel.types
+    return {
+      visitor: {
+        ImportDeclaration: function (path) {
+          const location = path.node.source.value;
+          const packageName = 'tungsten';
+          if (location.startsWith(packageName)) {
+            path.node.source.value = `/${packagesFolder}/${location}`;
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformSxyJsx.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BabelTransformSxyJsx.d.ts.map

package/dist/babelPlugins/BabelTransformSxyJsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformSxyJsx.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformSxyJsx.ts"],"names":[],"mappings":""}

package/dist/babelPlugins/BabelTransformSxyJsx.js

@@ -0,0 +1,56 @@
+export {};
+/*
+
+// BabelTransformSxyJsx
+// exports MakeBabelTransformSxyJsx (function)
+//
+// Basically the JSX runtime. Converts JSX into createElement calls
+
+import type { Babel } from './Babel.type.js'
+import type { NodePath } from '@babel/core'
+import type { JSXElement, JSXIdentifier, JSXMemberExpression } from '@babel/types'
+
+function JSXNameIsJSXIdentifier(name: JSXIdentifier | JSXMemberExpression): name is JSXIdentifier {
+    return name.type === 'JSXIdentifier'
+}
+
+// unfinshed
+export function MakeBabelTransformSxyJsx() {
+    return function BabelTransformSxyJsx(babel: Babel) {
+        const t = babel.types
+        let jsxElementsFound = false
+        return {
+            // pre: function (state) {
+                
+            // },
+            visitor: {
+                JSXElement: function (path: NodePath<JSXElement>) {
+                    // transform JSX element into a call to createElement
+                    jsxElementsFound = true
+                    const name = path.node.openingElement.name
+                    if (JSXNameIsJSXIdentifier(name)) {
+                        //const tagName = name.name
+                    } else { // JSXMemberExpression
+
+                    }
+                    const tagName = name.name
+                    const attributes = path.node.openingElement.attributes
+                    const children = path.node.children
+                    // create a babel function call
+                    const element = t.callExpression(t.identifier('createElement'), [t.stringLiteral(tagName), attributes, ...children])
+                    path.replaceWith(element)
+                }
+            },
+            post: function (state: any) {
+                if (jsxElementsFound) {
+                    // add an import for the createElement function
+                    const importDeclaration = t.importDeclaration([
+                        t.importSpecifier(t.identifier('createElement'), t.identifier('createElement'))
+                    ], t.stringLiteral('Framework/createElement.js'))
+                    state.file.path.node.body.unshift(importDeclaration)
+                }
+            },
+        }
+    }
+}
+*/

package/dist/babelPlugins/BabelTransformUniqueComponents.d.ts

@@ -0,0 +1,8 @@
+import type { types, NodePath } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+export default function MakeBabelTransformUniqueComponents(): (babel: BabelFake) => {
+    visitor: {
+        JSXOpeningElement(path: NodePath<types.JSXOpeningElement>): void;
+    };
+};
+//# sourceMappingURL=BabelTransformUniqueComponents.d.ts.map

package/dist/babelPlugins/BabelTransformUniqueComponents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformUniqueComponents.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformUniqueComponents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAcnD,MAAM,CAAC,OAAO,UAAU,kCAAkC,KACP,OAAO,SAAS;;gCAO3B,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC;;EAwBxE"}

package/dist/babelPlugins/BabelTransformUniqueComponents.js

@@ -0,0 +1,30 @@
+import { TungstenError } from "../TungstenError.js";
+const uidKey = '__u';
+function AttributeIsJSXAttribute(attribute) {
+  return attribute.type === 'JSXAttribute';
+}
+function AttributeIsJSXSpreadAttribute(attribute) {
+  return attribute.type === 'JSXSpreadAttribute';
+}
+export default function MakeBabelTransformUniqueComponents(/*opts: Opts*/
+) {
+  return function BabelTransformUniqueComponents(babel) {
+    const make = babel.types;
+    let uid = 1;
+    return {
+      visitor: {
+        JSXOpeningElement(path) {
+          // check for conflicting key
+          for (const attr of path.node.attributes) {
+            if (AttributeIsJSXAttribute(attr)) {
+              if (attr.name.name === uidKey) {
+                throw new TungstenError(`BabelTransformUniqueComponents error: JSX attribute ${uidKey} is reserved. Do not use it.`);
+              }
+            }
+          }
+          path.node.attributes.push(make.jsxAttribute(make.jsxIdentifier(uidKey), make.jsxExpressionContainer(make.numberLiteral(uid++))));
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTypes.d.ts

@@ -0,0 +1,6 @@
+import type * as BabelCore from '@babel/core';
+export { BabelCore };
+export { NodePath, PluginPass } from '@babel/core';
+export type Babel = typeof BabelCore;
+export * as BabelTypes from '@babel/types';
+//# sourceMappingURL=BabelTypes.d.ts.map

package/dist/babelPlugins/BabelTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTypes.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,CAAA;AACpB,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAClD,MAAM,MAAM,KAAK,GAAG,OAAO,SAAS,CAAC;AAErC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA"}

package/dist/babelPlugins/BabelTypes.js

@@ -0,0 +1,3 @@
+export { NodePath } from '@babel/core';
+//import type { types as Types } from '@babel/core';
+export * as BabelTypes from '@babel/types';

package/dist/babelPlugins/fixImportsInSassErrorMessage.d.ts

@@ -0,0 +1,8 @@
+import type { ModifySassImportItem } from '../build/modifySassImports.js';
+type FixImportsInSassErrorMessageResult = {
+    message: string;
+    foundImportError: boolean;
+};
+export declare function fixImportsInSassErrorMessage(message: string, map: ModifySassImportItem[]): FixImportsInSassErrorMessageResult;
+export {};
+//# sourceMappingURL=fixImportsInSassErrorMessage.d.ts.map

package/dist/babelPlugins/fixImportsInSassErrorMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixImportsInSassErrorMessage.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/fixImportsInSassErrorMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAazE,KAAK,kCAAkC,GAAG;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED,wBAAgB,4BAA4B,CACxC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,EAAE,GAC7C,kCAAkC,CAgGpC"}

package/dist/babelPlugins/fixImportsInSassErrorMessage.js

@@ -0,0 +1,93 @@
+import { throwError } from "../throwError.js";
+// RegEx: @use or @import, 0 or spaces or tabs, followed by an import target in single or double quotes
+const useOrImportRegex = /@(?:use|import)[ \t]*(?:'([^']+)'|"([^']+)")/g;
+// the line optionally starts with digits, spaces then pipe |, and after has 1 or more ^, and to the left and the right is only spaces or more carets
+// detects lines like '   ^^^^^^^^^^^     ^^^^^^^^^^^'
+// and '4 |   ^^^^^^^^^^^     ^^^^^^^^^^^'
+const lineIsCaretLineRegex = /^(?:\d* *│)?[ ^]*\^+[ ^]*$/;
+const ansiControlCharsRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g; // eslint-disable-line no-control-regex
+export function fixImportsInSassErrorMessage(message, map) {
+  let foundImportError = false;
+  const lines = message.split('\n');
+  //console.log('initial',  lines.join('\n'))
+  //const out = []
+  const mapObject = {};
+  for (const item of map) {
+    mapObject[item.to] = item.target;
+  }
+  //console.log('mapObject', mapObject)
+  //for (let [k, line] of Object.entries(lines)) {
+  lines.forEach((line, index) => {
+    //console.log(index, line)
+    //let offset = 0 // keep track of how many chars the line has been adjusted by, without modification of the next line
+    let match;
+    const nextLine = lines[index + 1];
+    //console.log(nextLine)
+    // for (let i = 0; i < nextLine.length; i++) {
+    //     console.log('nextLine', i, nextLine[i])
+    // }
+    const nextLineIsCaretLine = nextLine !== undefined && lineIsCaretLineRegex.test(nextLine.replace(ansiControlCharsRegex, ''));
+    //console.log('nextLineIsCaretLine', nextLineIsCaretLine)
+    while ((match = useOrImportRegex.exec(line)) !== null) {
+      //console.log('match', match)
+      //console.log('useOrImportRegex.lastIndex', useOrImportRegex.lastIndex)
+      //return line
+      const target = match[1] ?? match[2];
+      if (target === undefined) {
+        throwError('fixImportsInSassErrorMessage()', 'matched an import without a quoted target');
+      }
+      const start = match.index + Math.max(match[0].indexOf(`'`), match[0].indexOf(`"`)) + 1;
+      const len = target.length;
+      //console.log('target', target)
+      //console.log('in', target in mapObject)
+      //for (const k in mapObject) {
+      //console.log('comp', k, target, k === target)
+      //}
+      if (target in mapObject) {
+        const replacement = mapObject[target];
+        if (replacement === undefined) {
+          throwError('fixImportsInSassErrorMessage()', `missing mapped replacement for ${target}`);
+        }
+        const newLen = replacement.length;
+        //console.log('replacing')
+        line = line.slice(0, start) + replacement + line.slice(start + len);
+        //console.log(line)
+        //console.log('new last index', start + newLen + 1)
+        useOrImportRegex.lastIndex = start + newLen + 1;
+        // if the next line has ^^^^ at the same position
+        const nextLine = lines[index + 1];
+        //console.log('offset is', offset)
+        //console.log('slice', nextLine.slice(start + offset, start + len + offset))
+        if (nextLineIsCaretLine) {
+          if (nextLine === undefined) {
+            throwError('fixImportsInSassErrorMessage()', 'expected a caret line after the Sass import error');
+          }
+          //if (nextLine !== undefined && nextLine.slice(start + offset, start + len + offset) === '^'.repeat(len)) {
+          const nextLineSlice = nextLine.slice(start, start + len);
+          let insertChar = '';
+          if (nextLineSlice === '^'.repeat(len)) {
+            foundImportError = true;
+            insertChar = '^';
+          } else if (nextLineSlice === ' '.repeat(len)) {
+            insertChar = ' ';
+          } else {
+            throwError('fixImportsInSassErrorMessage()', 'nextLineSlice had unexpected content: ' + nextLineSlice);
+          }
+          lines[index + 1] = nextLine.slice(0, start) + insertChar.repeat(newLen) + nextLine.slice(start + len);
+          // console.log('trying to adjust carets')
+          // console.log(nextLine.slice(0, start + offset))
+          // console.log('^'.repeat(newLen))
+          // console.log(nextLine.slice(start + len + offset))
+        } else {
+          //offset += (len - newLen)
+        }
+      }
+      lines[index] = line;
+      //console.log('interim result',  lines.join('\n'))
+    }
+  });
+  return {
+    message: lines.join('\n'),
+    foundImportError
+  };
+}

package/dist/babelPlugins/fixImportsInSassErrorMessage.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fixImportsInSassErrorMessage.sxyt.d.ts.map

package/dist/babelPlugins/fixImportsInSassErrorMessage.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixImportsInSassErrorMessage.sxyt.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/fixImportsInSassErrorMessage.sxyt.ts"],"names":[],"mappings":""}