tungsten 0.1.7 → 0.1.25

package/dist/babelPlugins/BabelTransformBindDirect.js

@@ -0,0 +1,169 @@
+//import { T } from '@babel/core'
+import { TungstenError } from "../TungstenError.js";
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+const bindPropName = 'bind';
+function ExistingJsxAttributeValueIsExpressionContainer(v) {
+  return v.type === 'JSXExpressionContainer';
+}
+function ExpressionIsThisExpressionOrMemberExpression(expression) {
+  return expression.type === 'ThisExpression' || expression.type === 'MemberExpression';
+}
+function ExpressionIsIdentifier(expression) {
+  return expression.type === 'Identifier';
+}
+function NodeIsPrivateName(node) {
+  return node.type === 'PrivateName';
+}
+function AssertNodeIsJSXOpeningElement(node) {
+  if (node.type !== 'JSXOpeningElement') {
+    throw new TungstenError(`Node ${node} was not a JSXOpeningElement`);
+  }
+}
+export function MakeBabelTransformBindDirect( /*opts: Opts*/
+) {
+  return function BabelTransformBindDirect(babel) {
+    const make = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      visitor: {
+        JSXAttribute(path, state) {
+          if (path.node.name.name === bindPropName) {
+            if (!path.node.value) {
+              throw new TungstenError(`BabelTransformBind() error: bind prop is empty`);
+            }
+            const attributeValue = path.node.value;
+            if (!ExistingJsxAttributeValueIsExpressionContainer(attributeValue)) {
+              throw new TungstenError(`BabelTransformBind() error: bind prop should be an expression: {xxx}`);
+            }
+            if (attributeValue.expression.type !== 'MemberExpression') {
+              throw new TungstenError(`BabelTransformBind() error: bind prop should be member expression, e.g. {a.y}`);
+            }
+            const originalVariable = attributeValue.expression;
+            const variablePartsTemp = [];
+            let remaining = originalVariable;
+            while (remaining.type === 'MemberExpression') {
+              variablePartsTemp.push(remaining);
+              // {
+              //     property: remaining.property,
+              //     computed: remaining.computed,
+              // })
+              if (!ExpressionIsThisExpressionOrMemberExpression(remaining.object)) {
+                throw new TungstenError(`BabelTransformBind error: expected object in` + ` bind value to be ThisExpression or MemberExpression.` + ` Bind value must be a property on this, e.g. bind={this.foo}.` + ` Got ${remaining.object.type}: ${remaining.object}}`);
+              }
+              remaining = remaining.object;
+            }
+            // if (remaining.type !== 'ThisExpression') {
+            //     throw new Error(
+            //         'Babel Plugin Transform Bind Error:'
+            //             + ' the base of a variable passed to bind={} should be this, e.g. {this.foo}'
+            //             + ` Received ${remaining.name.name} instead`
+            //             + `\nfile: ${state.filename}`
+            //     )
+            // }
+            variablePartsTemp.push(remaining);
+            if (variablePartsTemp.length === 0) {
+              throw new Error('Babel Plugin Transform Bind Error:' + ' bind={} did not find a valid variable to bind.' + ' A state variable such as foo should be passed for this.state.foo,' + ' or foo.bar for this.state.foo.bar.' + `\nfile: ${state.filename}`);
+            }
+            variablePartsTemp.reverse();
+            const variableParts = variablePartsTemp;
+            // only part 0 can be ThisExpression, anything after must be MemberExpression
+            const part2 = variableParts[1];
+            const property = part2.property;
+            // check that the property is an identifier
+            // we might need to modify this to allow index access (state['foo'] instead of state.foo
+            if (NodeIsPrivateName(property)) {
+              throw new TungstenError('Babel Plugin Transform Bind Error:' + ' Expected bind object property to be an Identifier' + ` Instead got ${property.type}`);
+            }
+            if (!ExpressionIsIdentifier(property)) {
+              throw new TungstenError('Babel Plugin Transform Bind Error:' + ' Expected bind object property to be an Identifier' + ` Instead got ${property.type}`);
+            }
+            let variable = make.MemberExpression(make.Identifier('this'),
+            // only part 0 can be ThisExpression, anything after must be MemberExpression
+            property);
+            const stateBased = property.name === 'state';
+            // // rename the attribute to 'value' for state based (controlled value)
+            // // or otherwise defaultValue (uncontrolled input)
+            // path.node.name.name = (stateBased)
+            //     ? 'value'
+            //     : 'defaultValue'
+            // just always use value as our framework doesn't understand defaultValue yet
+            path.node.name.name = 'value';
+            for (let i = 2; i < variableParts.length; i++) {
+              // only part 0 can be other than MemberExpression
+              const varPart = variableParts[i];
+              variable = make.MemberExpression(variable, varPart.property, varPart.computed);
+            }
+            //// !!!! turn null/false/undef into empty string
+            //// it's nice, but would lead to inconsistency with ordinary
+            //// value = behaviour : (
+            // const valueContents = t.CallExpression(
+            //     t.MemberExpression(
+            //         t.Identifier('this'),
+            //         t.Identifier('__filterText')
+            //     ),
+            //     [variable]
+            // )
+            // path.node.value.expression = valueContents
+            // path.node.value.expression = variable
+            let originalOnChange = null;
+            let filter = null;
+            const parent = path.parent;
+            AssertNodeIsJSXOpeningElement(parent);
+            for (const att of parent.attributes) {
+              if (att.type === 'JSXAttribute') {
+                if (att.name.name === 'onChange') {
+                  originalOnChange = make.ExpressionStatement(make.CallExpression(att.value.expression, [make.Identifier('event'), make.Identifier('value')]));
+                }
+                if (att.name.name === 'filter') {
+                  filter = make.VariableDeclaration('const', [make.VariableDeclarator(make.Identifier('value'), make.CallExpression(att.value.expression, [make.MemberExpression(make.MemberExpression(make.Identifier('event'), make.Identifier('target')), make.Identifier('value')), make.Identifier('event')]))]);
+                }
+              }
+            }
+            // remove the original onChange attribute(s)
+            path.parent.attributes = path.parent.attributes.filter(att => att.type !== 'JSXAttribute' || att.name.name !== 'onChange' && att.name.name !== 'filter');
+            const stateSettingMode = 'assignment';
+            let setStateExpression;
+            let stateAssignmentExpression;
+            let setFieldExpression;
+            if (stateBased) {
+              if (stateSettingMode === 'assignment') {
+                stateAssignmentExpression = make.ExpressionStatement(make.AssignmentExpression('=', originalVariable, make.Identifier('value')));
+              } else {
+                //// unused
+                //// would only be useful for a back compat mode
+                if (variableParts.length === 3) {
+                  setStateExpression = make.ExpressionStatement(make.CallExpression(make.MemberExpression(make.Identifier('this'), make.Identifier('setState')), [make.ObjectExpression([make.ObjectProperty(make.StringLiteral(variableParts[2].property.name), make.Identifier('value'))])]));
+                } else {
+                  setStateExpression = make.ExpressionStatement(make.CallExpression(make.MemberExpression(make.Identifier('this'), make.Identifier('setStateDeep')), [make.ArrayExpression(variableParts.filter((p, k) => k >= 2).map(p => {
+                    return !p.computed ? make.StringLiteral(p.property.name) : p.property;
+                  })), make.Identifier('value')]));
+                }
+              }
+            } else {
+              setFieldExpression = make.ExpressionStatement(make.AssignmentExpression('=', variable, make.Identifier('value')));
+            }
+            const functionBodyExpressions = [];
+            const assignToValueVarExpression = make.VariableDeclaration('const', [make.VariableDeclarator(make.Identifier('value'), make.MemberExpression(make.MemberExpression(make.Identifier('event'), make.Identifier('target')), make.Identifier('value')))]);
+            if (filter) functionBodyExpressions.push(filter);else functionBodyExpressions.push(assignToValueVarExpression);
+            if (stateBased) {
+              if (stateSettingMode === 'assignment') {
+                functionBodyExpressions.push(stateAssignmentExpression);
+              } else {
+                //// unused
+                //// would only be useful for a back compat mode
+                functionBodyExpressions.push(setStateExpression);
+              }
+            } else functionBodyExpressions.push(setFieldExpression);
+            if (originalOnChange) functionBodyExpressions.push(originalOnChange);
+            const attr = make.JSXAttribute(make.JSXIdentifier('onKeyUp'), make.JSXExpressionContainer(make.ArrowFunctionExpression([make.Identifier('event')], make.BlockStatement(functionBodyExpressions))));
+            path.parent.attributes.push(attr);
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformBindVar.d.ts

@@ -0,0 +1,9 @@
+import type { Babel } from './Babel.type.js';
+import { NodePath, types } from '@babel/core';
+export declare function MakeBabelTransformBindVar(): (babel: Babel) => {
+    name: string;
+    visitor: {
+        JSXAttribute(path: NodePath<types.JSXAttribute>, state: any): void;
+    };
+};
+//# sourceMappingURL=BabelTransformBindVar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformBindVar.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformBindVar.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAS,MAAM,aAAa,CAAA;AA0FpD,wBAAgB,yBAAyB,YACQ,KAAK;;;2BAKnB,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,GAAG;;EAmQ1E"}

package/dist/babelPlugins/BabelTransformBindVar.js

@@ -0,0 +1,218 @@
+//import { T } from '@babel/core'
+import { TungstenError } from "../TungstenError.js";
+import { bindableHtmlElements } from "../binding/bindableHtmlElements.js";
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+const bindPropName = 'bind';
+function ExistingJsxAttributeValueIsExpressionContainer(v) {
+  return v.type === 'JSXExpressionContainer';
+}
+function ExpressionIsThisExpressionOrMemberExpression(expression) {
+  return expression.type === 'ThisExpression' || expression.type === 'MemberExpression';
+}
+function ExpressionIsIdentifier(expression) {
+  return expression.type === 'Identifier';
+}
+function NodeIsPrivateName(node) {
+  return node.type === 'PrivateName';
+}
+function AssertNodeIsJSXOpeningElement(node) {
+  if (node.type !== 'JSXOpeningElement') {
+    throw new TungstenError(`Node ${node} was not a JSXOpeningElement`);
+  }
+}
+function ExpressionOrJsxEmptyExpressionIsArrayExpression(ex) {
+  return ex.type === 'ArrayExpression';
+}
+function NameIsJSXIdentifier(name) {
+  return name.type === 'JSXIdentifier';
+}
+function AttributeIsJSXAttribute(att) {
+  return att.type === 'JSXAttribute';
+}
+function AttributeIsJSXSpreadAttribute(att) {
+  return att.type === 'JSXSpreadAttribute';
+}
+function AttributeValueIsJSXExpressionContainer(attributeValue) {
+  return !!attributeValue && attributeValue.type === 'JSXExpressionContainer';
+}
+// type BindVarTuple = [object, string]
+// function ArrayExpressionIsBindVarTuple(array: ArrayExpression): array is BindVarTupleExpression {
+// }
+function TupleElementIsIdentifierOrMemberExpressionOrCallExpression(element) {
+  return element !== null && (element.type === 'Identifier' || element.type === 'MemberExpression' || element.type === 'CallExpression');
+}
+function TupleElementIsIdentifierOrStringLiteralOrTaggedTemplateExpressionOrCallExpression(element) {
+  return element !== null && (element.type === 'Identifier' || element.type === 'StringLiteral' || element.type === 'TaggedTemplateExpression' || element.type === 'CallExpression');
+}
+export function MakeBabelTransformBindVar( /*opts: Opts*/
+) {
+  return function BabelTransformBindVar(babel) {
+    const make = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      visitor: {
+        JSXAttribute(path, state) {
+          // !!!! GUARD
+          if (path.node.name.name !== bindPropName) return;
+          const openingElement = path.parent;
+          AssertNodeIsJSXOpeningElement(openingElement);
+          // !!!! GUARD
+          const elementName = openingElement.name;
+          if (!NameIsJSXIdentifier(elementName) || !(elementName.name in bindableHtmlElements)) return;
+          if (!path.node.value) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop is empty`);
+          }
+          const attributeValue = path.node.value;
+          if (!ExistingJsxAttributeValueIsExpressionContainer(attributeValue)) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be an expression: {xxx}`);
+          }
+          // !!!!! bind var could be a literal tuple
+          // or instead an expression
+          const attributeValueExpression = attributeValue.expression;
+          if (!ExpressionOrJsxEmptyExpressionIsArrayExpression(attributeValueExpression)) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be a tuple: [object, 'prop']`);
+          }
+          const bindVarTuple = attributeValueExpression;
+          if (bindVarTuple.elements.length !== 2) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be a tuple: [object, 'prop']`);
+          }
+          const bindVarObjectExpression = bindVarTuple.elements[0];
+          const bindVarPropExpression = bindVarTuple.elements[1];
+          if (!TupleElementIsIdentifierOrMemberExpressionOrCallExpression(bindVarObjectExpression)) {
+            throw new TungstenError(`BabelTransformBind() error: the first element in the bind prop tuple must be a variable or function call`);
+          }
+          if (!TupleElementIsIdentifierOrStringLiteralOrTaggedTemplateExpressionOrCallExpression(bindVarPropExpression)) {
+            throw new TungstenError(`BabelTransformBind() error: the second element in the bind prop tuple must be a string, variable, or function call`);
+          }
+          //// determine whether the bind object is within component state
+          /*
+            //const originalVariable = attributeValueExpression
+                  
+          const variablePartsTemp: VariablePart[] = []
+          let remaining: (types.ThisExpression | types.MemberExpression) = bindVarObjectExpression
+              
+          while (remaining.type === 'MemberExpression') {
+              variablePartsTemp.push(remaining)
+              if ( ! ExpressionIsThisExpressionOrMemberExpression(remaining.object) ) {
+                  throw new TungstenError(
+                      `BabelTransformBind error: expected object in`
+                          + ` bind value to be ThisExpression or MemberExpression.`
+                          + ` Bind value must be a property on this, e.g. bind={this.foo}.`
+                          + ` Got ${remaining.object.type}: ${remaining.object}}`
+                  )
+              }
+              remaining = remaining.object
+          }
+              
+          variablePartsTemp.push(remaining)
+              
+          if (variablePartsTemp.length === 0) {
+              throw new Error(
+                  'Babel Plugin Transform Bind Error:'
+                          + ' bind={} did not find a valid variable to bind.'
+                          + ' A state variable such as foo should be passed for this.state.foo,'
+                          + ' or foo.bar for this.state.foo.bar.'
+                          + `\nfile: ${state.filename}`
+              )
+          }
+               variablePartsTemp.reverse()
+          const variableParts = variablePartsTemp as VariablePartsFinal
+               // only part 0 can be ThisExpression, anything after must be MemberExpression
+          const part2 = variableParts[1]
+          const property = part2.property
+               // check that the property is an identifier
+              // we might need to modify this to allow index access (state['foo'] instead of state.foo
+           if ( NodeIsPrivateName(property) ) {
+              throw new TungstenError(
+                  'Babel Plugin Transform Bind Error:'
+                      + ' Expected bind object property to be an Identifier'
+                      + ` Instead got ${property.type}`
+              )
+          }
+           if ( ! ExpressionIsIdentifier(property) ) {
+              throw new TungstenError(
+                  'Babel Plugin Transform Bind Error:'
+                      + ' Expected bind object property to be an Identifier'
+                      + ` Instead got ${property.type}`
+              )
+          }
+           let variable = make.MemberExpression(
+              make.Identifier('this'),
+                  // only part 0 can be ThisExpression, anything after must be MemberExpression
+              property
+          )
+                  
+          const stateBased = property.name === 'state'
+              
+              // just always use value as our framework doesn't understand defaultValue yet
+          path.node.name.name = 'value'
+           for (let i = 2; i < variableParts.length; i++) {
+                  // only part 0 can be other than MemberExpression
+              const varPart = variableParts[i] as types.MemberExpression
+              variable = make.MemberExpression(
+                  variable,
+                  varPart.property,
+                  varPart.computed
+              )
+          }
+           */
+          let originalOnChange = null;
+          let filter = null;
+          for (const att of openingElement.attributes) {
+            if (AttributeIsJSXAttribute(att)) {
+              if (att.name.name === 'onChange') {
+                const attributeValue = att.value;
+                if (!AttributeValueIsJSXExpressionContainer(attributeValue)) {
+                  throw new TungstenError(`BabelTransformBind() error: expected onChange attribute value to be a JSX Expression: {xxx}`);
+                }
+                originalOnChange = make.ExpressionStatement(make.CallExpression(attributeValue.expression, [make.Identifier('event'), make.Identifier('value')]));
+              }
+              if (att.name.name === 'filter') {
+                const attributeValue = att.value;
+                if (!AttributeValueIsJSXExpressionContainer(attributeValue)) {
+                  throw new TungstenError(`BabelTransformBind() error: expected filter attribute value to be a JSX Expression: {xxx}`);
+                }
+                filter = make.VariableDeclaration('const', [make.VariableDeclarator(make.Identifier('value'), make.CallExpression(attributeValue.expression, [make.MemberExpression(make.MemberExpression(make.Identifier('event'), make.Identifier('target')), make.Identifier('value')), make.Identifier('event')]))]);
+              }
+            }
+          }
+          // remove the original onChange attribute(s)
+          openingElement.attributes = openingElement.attributes.filter(att => att.type !== 'JSXAttribute' || att.name.name !== 'onChange' && att.name.name !== 'filter');
+          let assignmentExpression;
+          //if (stateBased) {
+          assignmentExpression = make.ExpressionStatement(make.AssignmentExpression('=', make.MemberExpression(bindVarObjectExpression, bindVarPropExpression), make.Identifier('value')));
+          // } else {
+          //     setFieldExpression = make.ExpressionStatement(
+          //         make.AssignmentExpression(
+          //             '=',
+          //             variable,
+          //             make.Identifier('value')
+          //         )
+          //     )
+          // }
+          const functionBodyExpressions = [];
+          const assignToValueVarExpression = make.VariableDeclaration('const', [make.VariableDeclarator(make.Identifier('value'), make.MemberExpression(make.MemberExpression(make.Identifier('event'), make.Identifier('target')), make.Identifier('value')))]);
+          if (filter) functionBodyExpressions.push(filter);else functionBodyExpressions.push(assignToValueVarExpression);
+          // if (stateBased) {
+          //     if (stateSettingMode === 'assignment') {
+          //         functionBodyExpressions.push(stateAssignmentExpression)
+          //     } else {
+          //                 //// unused
+          //                 //// would only be useful for a back compat mode
+          //         functionBodyExpressions.push(setStateExpression)
+          //     }
+          // }
+          // else functionBodyExpressions.push(setFieldExpression)
+          functionBodyExpressions.push(assignmentExpression);
+          if (originalOnChange) functionBodyExpressions.push(originalOnChange);
+          const attr = make.JSXAttribute(make.JSXIdentifier('onKeyUp'), make.JSXExpressionContainer(make.ArrowFunctionExpression([make.Identifier('event')], make.BlockStatement(functionBodyExpressions))));
+          openingElement.attributes.push(attr);
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformCjsToEsm.d.ts

@@ -0,0 +1,12 @@
+import type { NodePath, types } from '@babel/core';
+import type { Babel } from './Babel.type.js';
+export declare function MakeBabelTransformCjsToEsm(): (babel: Babel) => {
+    pre(state: any): void;
+    visitor: {
+        CallExpression(path: NodePath<types.CallExpression>): void;
+        Identifier(path: NodePath<types.Identifier>): void;
+        MemberExpression(path: NodePath<types.MemberExpression>): void;
+    };
+    post(state: any): void;
+};
+//# sourceMappingURL=BabelTransformCjsToEsm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCjsToEsm.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCjsToEsm.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAmE5C,wBAAgB,0BAA0B,YACQ,KAAK;eAahC,GAAG;;6BAmBW,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC;yBAwBlC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC;+BAMpB,QAAQ,CAAC,KAAK,CAAC,gBAAgB,CAAC;;gBAU/C,GAAG;EA2F1B"}

package/dist/babelPlugins/BabelTransformCjsToEsm.js

@@ -0,0 +1,154 @@
+//// how do we know if an 
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { init as lexerInit, parse as lexerParse } from 'cjs-module-lexer';
+lexerInit();
+const filenameAndDirnameCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+let __filename = fileURLToPath(import.meta.url);
+let __dirname = dirname(__filename);`;
+const createRequireCode = `import { createRequire } from 'module';
+const require = createRequire(import.meta.url)`;
+const exportsStartCode = `let exports = {};
+let module = { exports };`;
+const exportsEndCode = `export default module.exports;`;
+const exportNamesFromFileCache = {};
+function getExportNamesFromFile(file) {
+  const cache = exportNamesFromFileCache;
+  if (file in cache) {
+    return cache[file];
+  } else {
+    const code = readFileSync(file, 'utf8');
+    return cache[file] = getExportNamesFromCode(code, file);
+  }
+}
+function getExportNamesFromCode(code, filename) {
+  const combinedExports = {};
+  const {
+    exports,
+    reexports: reExports
+  } = lexerParse(code);
+  for (const reExport of reExports) {
+    const _require = createRequire(filename);
+    const target = _require.resolve(reExport);
+    const secondaryNames = getExportNamesFromFile(target);
+    for (const e of secondaryNames) {
+      combinedExports[e] = true;
+    }
+  }
+  for (const e of exports) {
+    combinedExports[e] = true;
+  }
+  return Object.keys(combinedExports);
+}
+export function MakeBabelTransformCjsToEsm( /*opts: Opts*/
+) {
+  return function BabelTransformCjsToEsm(babel) {
+    const t = babel.types;
+    const createRequire = babel.parse(createRequireCode).program.body;
+    const filenameAndDirname = babel.parse(filenameAndDirnameCode).program.body;
+    const exportsStart = babel.parse(exportsStartCode).program.body;
+    const exportsEnd = babel.parse(exportsEndCode).program.body;
+    //let identifiers
+    let imports;
+    let importNum;
+    let addFilenameAndDirname;
+    let addCreateRequire;
+    return {
+      pre(state) {
+        //identifiers = {}
+        imports = [];
+        importNum = 0;
+        addFilenameAndDirname = false;
+        addCreateRequire = false;
+        // wrap everything in a scoping code block to prevent naming conficts when exporting at the end
+        const body = state.ast.program.body;
+        state.ast.program.body = [t.BlockStatement([...body])];
+        // // grab the whole file contents
+        // const body = state.ast.program.body
+        // // add a block statement containing a copy of this content at the start of the body
+        // state.path.unshiftContainer('body', t.BlockStatement([...body]))
+        //  /// truncate the body to 1 item, removing the original content
+        // body.length = 1
+      },
+      visitor: {
+        CallExpression(path) {
+          const callee = path.node.callee;
+          if (callee.type === 'Identifier' && callee.name === 'require') {
+            imports.push(path.node.arguments);
+            //const newEx = t.AwaitExpression(
+            //    t.CallExpression(
+            //        t.Import(),
+            //        path.node.arguments
+            //    )
+            //)
+            const newEx = t.MemberExpression(t.Identifier('__tungsten_cjs_to_esm_imports'), t.NumericLiteral(importNum),
+            // pretty hard to read output code
+            true);
+            path.replaceWith(newEx);
+            importNum++;
+            // do we wanna cache???
+            //
+          }
+        },
+        Identifier(path) {
+          //identifiers[path.node.name] = true
+          if (path.node.name === '__filename' || path.node.name === '__dirname') {
+            addFilenameAndDirname = true;
+          }
+        },
+        MemberExpression(path) {
+          const node = path.node;
+          if (node.object.type === 'Identifier' && node.object.name === 'require' && node.property.type === 'Identifier' && node.property.name === 'resolve') {
+            addCreateRequire = true;
+          }
+        }
+      },
+      post(state) {
+        const importsStatement = t.VariableDeclaration('const', [t.VariableDeclarator(t.Identifier('__tungsten_cjs_to_esm_imports'), t.AwaitExpression(t.CallExpression(t.MemberExpression(t.Identifier('Promise'), t.Identifier('all')), [t.ArrayExpression(imports.map(imp => {
+          const source = imp[0].value;
+          //// We don't wanna change imports, because we need to resolve and alter them
+          //// in the next step
+          // if ( // danger: death by regex
+          //     source.includes('/')
+          //     && ! /^@[^/]+\/[^/]+$/.test(source)
+          //     && ! /(.js|.cjs|.mjs|.json)$/.test(source)
+          // ) {
+          //     if (source.split('/').pop().includes('.')) {
+          //         console.log(`babel-plugin-sxy-transform-cjs-to-esm warning:`
+          //             + ` require location ${source} file contains a dot, but we did not`
+          //             + ` recognise the extension. Adding .js`)
+          //     }
+          //     source += '.js'
+          // }
+          return t.AwaitExpression(t.CallExpression(t.Import(), [t.StringLiteral(source)]));
+        }))])))]);
+        state.path.unshiftContainer('body', importsStatement);
+        //for (const imp of imports) {
+        //  	const importDeclaration = t.ImportDeclaration(
+        //        [t.ImportDefaultSpecifier(
+        //            t.Identifier(varNameForImport(imp[0].value))
+        //        )],
+        //        imp[0]
+        //    )
+        //   state.path.unshiftContainer('body', importDeclaration)
+        //}
+        // reverse the order, because we are unshifting 
+        if (addCreateRequire) {
+          state.path.unshiftContainer('body', createRequire);
+        }
+        if (addFilenameAndDirname) {
+          state.path.unshiftContainer('body', filenameAndDirname);
+        }
+        state.path.unshiftContainer('body', exportsStart);
+        const names = getExportNamesFromCode(state.code, state.opts.filename);
+        for (const name of names) {
+          if (name === 'default') continue; /// cannot export named variables called default - this is reserved for the default export
+          const namedExport = t.ExportNamedDeclaration(t.VariableDeclaration('const', [t.VariableDeclarator(t.Identifier(name), t.MemberExpression(t.MemberExpression(t.identifier('module'), t.identifier('exports')), t.StringLiteral(name), true))]));
+          state.path.pushContainer('body', namedExport);
+        }
+        state.path.pushContainer('body', exportsEnd);
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformCjsToFunction.d.ts

@@ -0,0 +1,16 @@
+import type { Directive, Identifier } from 'babel-types';
+import type { NodePath } from '@babel/core';
+import type { Babel } from './Babel.type.js';
+type Opts = {
+    dependencies: string[];
+};
+export declare function MakeBabelTransformCjsToFunction(opts: Opts): (babel: Babel) => {
+    pre(state: any): void;
+    visitor: {
+        Identifier(path: NodePath<Identifier>): void;
+        Directive(path: NodePath<Directive>): void;
+    };
+    post(state: any): void;
+};
+export {};
+//# sourceMappingURL=BabelTransformCjsToFunction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCjsToFunction.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCjsToFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAa5C,KAAK,IAAI,GAAG;IACR,YAAY,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,IAAI,WACH,KAAK;eASrC,GAAG;;yBAkBO,QAAQ,CAAC,UAAU,CAAC;wBAMrB,QAAQ,CAAC,SAAS,CAAC;;gBAM3B,GAAG;EA4B1B"}

package/dist/babelPlugins/BabelTransformCjsToFunction.js

@@ -0,0 +1,54 @@
+//// let or const??
+const filenameAndDirnameCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+let __filename = fileURLToPath(import.meta.url);
+let __dirname = dirname(__filename);`;
+const createRequireCode = `import { createRequire } from 'module';
+const require = createRequire(import.meta.url)`;
+export function MakeBabelTransformCjsToFunction(opts) {
+  return function BabelTransformCjsToFunction(babel) {
+    const t = babel.types;
+    const createRequire = babel.parse(createRequireCode).program.body;
+    const filenameAndDirname = babel.parse(filenameAndDirnameCode).program.body;
+    let identifiers;
+    let addFilenameAndDirname;
+    let addCreateRequire;
+    return {
+      pre(state) {
+        identifiers = {};
+        addFilenameAndDirname = false;
+        addCreateRequire = false;
+        // wrap everything in a fucntion and export it as default
+        const body = state.ast.program.body;
+        const func = t.ExportDefaultDeclaration(t.FunctionDeclaration(t.Identifier('commonJsModule'), [t.identifier('module'), t.Identifier('exports'), t.Identifier('require')], t.BlockStatement([...body])));
+        state.ast.program.body = [func];
+      },
+      visitor: {
+        Identifier(path) {
+          identifiers[path.node.name] = true;
+          if (path.node.name === '__filename' || path.node.name === '__dirname') {
+            addFilenameAndDirname = true;
+          }
+        },
+        Directive(path) {
+          if (path.node.value.value === 'use strict') {
+            path.remove();
+          }
+        }
+      },
+      post(state) {
+        // reverse the order, because we are unshifting 
+        if (addCreateRequire) {
+          state.path.unshiftContainer('body', createRequire);
+        }
+        if (addFilenameAndDirname) {
+          state.path.unshiftContainer('body', filenameAndDirname);
+        }
+        //if (state.opts.filename.endsWith('highlight.js')) {
+        //console.log(chalk.purple`deps for ${state.opts.filename}`, opts.dependencies)    
+        //}
+        state.path.unshiftContainer('body', t.ExportNamedDeclaration(t.VariableDeclaration('const', [t.VariableDeclarator(t.Identifier('deps'), t.ArrayExpression(opts.dependencies.map(d => t.StringLiteral(d))))])));
+      }
+    };
+  };
+}