tungsten 0.2.1 → 0.2.3

package/dist/babelPlugins/BabelTransformCjsToFunction2.js

@@ -0,0 +1,193 @@
+//function parse() {
+//	return {
+//      exports: [],
+//      reexports: []
+//    }
+//}
+//// 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 = `function createRequire() {}`;
+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;
+    //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 fucntion and export it as default
+        const body = state.ast.program.body;
+        //state.ast.program.body = [t.blockStatement([...body])] // just wrapping it in { }
+        const func = t.exportDefaultDeclaration(t.functionDeclaration(t.identifier('commonJsModule'), [t.identifier('module'), t.identifier('require')], t.blockStatement([...body
+        //t.returnStatement(t.memberExpression(
+        ////    t.identifier('module'),
+        //    t.identifier('exports')
+        //))
+        ])));
+        state.ast.program.body = [func];
+        // // 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') {
+            const source = path.node.arguments[0];
+            if (source === undefined || source.type !== 'StringLiteral') {
+              throw new Error('BabelTransformCjsToFunction error: require() must have a string literal as its first argument');
+            }
+            //console.log(path.node)
+            path.replaceWith(t.callExpression(t.memberExpression(t.identifier('__tungsten_deps'),
+            //t.identifier('foo'),
+            t.stringLiteral(source.value), true), []));
+            //         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
+        //     }
+        // }
+        Directive(path) {
+          if (path.node.value.value === 'use strict') {
+            path.remove();
+          }
+        }
+      },
+      post(state) {
+        //console.log('imports', imports)
+        //console.log('identifiers', identifiers)
+        // 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
+        //                     //console.log(source)
+        //                     //const a = source.includes('/')
+        //                     //const b = ! /^@[^\/]+\/[^\/]+$/.test(source)
+        //                     //const c = ! /(.js|.cjs|.mjs|.json)$/.test(source)
+        //                     //if ( 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', t.expressionStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('all')), [t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('values')), [t.identifier('deps')])]))));
+        state.path.unshiftContainer('body', t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier('deps'), t.objectExpression(opts.dependencies.map(d => t.objectProperty(t.stringLiteral(d), t.callExpression(t.import(), [t.stringLiteral(d)]), true))))])));
+        //state.path.unshiftContainer('body', t.variableDeclaration(
+        //	'const',
+        //	[t.variableDeclarator(
+        //    	t.identifier('deps'),
+        //        t.arrayExpression([
+        //          t.stringLiteral('foo.js'),
+        //          t.stringLiteral('./bar.js')
+        //        ])
+        //    )]
+        //))
+        //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/BabelTransformComponentState.d.ts

@@ -0,0 +1,22 @@
+import type { NodePath } from '@babel/core';
+import { BabelFake } from './BabelFakeType.js';
+import { AssignmentExpression, CallExpression, ClassMethod, ClassProperty, JSXExpressionContainer, UpdateExpression, VariableDeclaration } from '@babel/types';
+export declare function MakeBabelTransformComponentState(): (babel: BabelFake) => {
+    pre(): void;
+    visitor: {
+        ClassMethod: {
+            enter(path: NodePath<ClassMethod | ClassProperty>): void;
+            exit(path: NodePath<ClassMethod | ClassProperty>): void;
+        };
+        ClassProperty: {
+            enter(path: NodePath<ClassMethod | ClassProperty>): void;
+            exit(path: NodePath<ClassMethod | ClassProperty>): void;
+        };
+        AssignmentExpression(path: NodePath<AssignmentExpression>): void;
+        UpdateExpression(path: NodePath<UpdateExpression>): void;
+        CallExpression(path: NodePath<CallExpression>): void;
+        VariableDeclaration(path: NodePath<VariableDeclaration>): void;
+        JSXExpressionContainer(path: NodePath<JSXExpressionContainer>): void;
+    };
+};
+//# sourceMappingURL=BabelTransformComponentState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformComponentState.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformComponentState.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAQ,QAAQ,EAAS,MAAM,aAAa,CAAA;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EACH,oBAAoB,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAChE,sBAAsB,EAAoB,gBAAgB,EAAE,mBAAmB,EAClF,MAAM,cAAc,CAAA;AAGrB,wBAAgB,gCAAgC,KACC,OAAO,SAAS;;;;wBAuFzC,QAAQ,CAAC,WAAW,GAAG,aAAa,CAAC;uBAOtC,QAAQ,CAAC,WAAW,GAAG,aAAa,CAAC;;;wBAPpC,QAAQ,CAAC,WAAW,GAAG,aAAa,CAAC;uBAOtC,QAAQ,CAAC,WAAW,GAAG,aAAa,CAAC;;mCAgBjB,QAAQ,CAAC,oBAAoB,CAAC;+BA0BlC,QAAQ,CAAC,gBAAgB,CAAC;6BAU5B,QAAQ,CAAC,cAAc,CAAC;kCAqCnB,QAAQ,CAAC,mBAAmB,CAAC;qCAgB1B,QAAQ,CAAC,sBAAsB,CAAC;;EA0B5E"}

package/dist/babelPlugins/BabelTransformComponentState.js

@@ -0,0 +1,191 @@
+// BabelTransformComponentState
+// exports MakeBabelTransformComponentState (function)
+//
+// currently not used
+// proxy and deproxy solution seems preferable
+import { arrayMutatingFunctions } from "../mutatingFunctions.js";
+import { throwError } from "../throwError.js";
+export function MakeBabelTransformComponentState(/*opts: Opts*/
+) {
+  return function BabelTransformComponentState(babel) {
+    const t = babel.types;
+    //let usesStateCopy = false
+    //let usesStateUpdate = false
+    let insideInit = false;
+    function nodeIsThisDotState(node) {
+      if (node.type === 'MemberExpression') {
+        const left = findLeftmostObject(node);
+        if (memberExpressionIsThisDotState(left)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    // ?? is this wrong
+    function memberExpressionIsThisDotState(memberExpressionNode) {
+      const n = memberExpressionNode;
+      const o = n.object;
+      const p = n.property;
+      return o.type === 'ThisExpression' && (p.type === 'Identifier' && p.name === 'state' || p.type === 'StringLiteral' && p.value === 'state');
+    }
+    // ?? is this wrong
+    function findLeftmostObject(memberExpressionNode) {
+      let left = memberExpressionNode;
+      //console.log('v1', v)
+      while (left.object.type === 'MemberExpression') {
+        left = left.object;
+        //console.log('v2', v)
+      }
+      return left;
+    }
+    function addUpdateState(path) {
+      const replacement = t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__notifyStateUpdated')), [path.node]);
+      path.replaceWith(replacement);
+      path.skip();
+    }
+    function addUpdateStateArray(path) {
+      if (path.node.callee.type !== 'MemberExpression') {
+        throwError('BabelTransformComponentState', 'expected an array mutation call to use a member-expression callee');
+      }
+      const replacement = t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__notifyStateUpdated')), [path.node.callee.object, path.node]);
+      path.replaceWith(replacement);
+      path.skip();
+    }
+    function copyCall(variable) {
+      return t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__stateCopy')), [variable]);
+    }
+    function varDecCopyVar(variableDeclarator) {
+      //console.log(variableDeclarator)
+      if (variableDeclarator.init == null) {
+        throwError('BabelTransformComponentState', 'expected a variable declarator to have an initializer');
+      }
+      variableDeclarator.init = copyCall(variableDeclarator.init);
+    }
+    const ClassMethodOrProperty = {
+      enter(path) {
+        //console.log(path.node)
+        const key = path.node.key;
+        if (key.type === 'Identifier' && key.name === 'init' || key.type === 'StringLiteral' && key.value === 'init') {
+          insideInit = true;
+        }
+      },
+      exit(path) {
+        const key = path.node.key;
+        if (key.type === 'Identifier' && key.name === 'init' || key.type === 'StringLiteral' && key.value === 'init') {
+          insideInit = false;
+        }
+      }
+    };
+    return {
+      pre() {
+        //usesStateUpdate = false
+        //usesStateCopy = false
+      },
+      visitor: {
+        ClassMethod: ClassMethodOrProperty,
+        ClassProperty: ClassMethodOrProperty,
+        AssignmentExpression(path) {
+          const node = path.node;
+          // update state
+          if (!insideInit) {
+            let left = node.left;
+            if (left.type === 'MemberExpression') {
+              left = findLeftmostObject(left);
+              if (memberExpressionIsThisDotState(left)) {
+                addUpdateState(path);
+                //return
+              }
+            }
+          }
+          //return
+          // state pass by value
+          if (nodeIsThisDotState(node.right)) {
+            //console.log('this.state');
+            //console.log(node)
+            node.right = copyCall(node.right);
+            path.skip();
+          }
+        },
+        UpdateExpression(path) {
+          if (insideInit) return; // guard
+          const variable = path.node.argument;
+          if (variable.type === 'MemberExpression') {
+            const left = findLeftmostObject(variable);
+            if (memberExpressionIsThisDotState(left)) {
+              addUpdateState(path);
+            }
+          }
+        },
+        CallExpression(path) {
+          //console.log(path.node)
+          //const node = path.node
+          // update state when using mutating functions
+          const callee = path.node.callee;
+          if (callee.type === 'MemberExpression') {
+            const property = callee.property;
+            if (property.type === 'Identifier' && arrayMutatingFunctions.some(functionName => functionName === property.name)) {
+              const left = findLeftmostObject(callee);
+              //console.log('left', left)
+              if (memberExpressionIsThisDotState(left)) {
+                addUpdateStateArray(path);
+              }
+            }
+          }
+          // state pass by value for state args
+          //console.log('call ex')
+          let i = 0;
+          for (const arg of path.node.arguments) {
+            if (arg.type === 'SpreadElement' || arg.type === 'ArgumentPlaceholder') {
+              throwError('BabelTransformComponentState', `cannot inspect a ${arg.type} call argument for component state`);
+            }
+            if (nodeIsThisDotState(arg)) {
+              //console.log(i, arg)
+              path.node.arguments[i] = copyCall(arg);
+            }
+            i++;
+          }
+          path.skip();
+        },
+        VariableDeclaration(path) {
+          for (const dec of path.node.declarations) {
+            //console.log(dec)
+            if (dec.init) {
+              if (nodeIsThisDotState(dec.init)) {
+                varDecCopyVar(dec);
+              }
+              //if (dec.init.type === 'MemberExpression') {
+              //    const left = findLeftmostObject(dec.init)
+              //    if (memberExpressionIsThisDotState(left)) {
+              //        varDecCopyVar(dec)
+              //    }
+              //}
+            }
+          }
+        },
+        JSXExpressionContainer(path) {
+          const e = path.node.expression;
+          if (e.type === 'JSXEmptyExpression') {
+            throwError('BabelTransformComponentState', 'encountered an empty JSX expression container');
+          }
+          if (nodeIsThisDotState(e)) {
+            path.node.expression = copyCall(e);
+          }
+        }
+      }
+      //post(state) {
+      //if (usesStateCopy) {
+      //  	 const importDeclaration = t.importDeclaration(
+      //        [
+      //            t.importSpecifier(
+      //                t.identifier('stateCopy'),
+      //                t.identifier('stateCopy')
+      //            )
+      //        ],
+      //        t.stringLiteral('tungsten')
+      //    )
+      //    state./*file.*/path.node.body.unshift(importDeclaration)
+      //}
+      //}
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformComponentStyles.d.ts

@@ -0,0 +1,33 @@
+import { Babel, NodePath } from './BabelTypes.js';
+import { TaggedTemplateExpression } from '@babel/types';
+type Opts = {
+    projectAbsCodeDir: string;
+    projectAbsSourceDir: string;
+    projectAbsStyleImportDir: string;
+    classNameFormat?: string;
+    cssOutputFile?: string;
+    cssModulesOutputDir?: string;
+    functionNames?: string[];
+};
+export declare function MakeBabelTransformComponentStyles(opts: Opts): (babel: Babel) => {
+    name: string;
+    pre(state: {
+        opts: {
+            stylesheetIndex: number;
+        };
+        iteration: number;
+    }): void;
+    visitor: {
+        TaggedTemplateExpression(path: NodePath<TaggedTemplateExpression>, state: {
+            filename: string;
+            file: {
+                opts: {
+                    stylesheetIndex: number;
+                };
+            };
+            __stylesheetIndex: number;
+        }): void;
+    };
+};
+export {};
+//# sourceMappingURL=BabelTransformComponentStyles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformComponentStyles.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformComponentStyles.ts"],"names":[],"mappings":"AAwCA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAc,MAAM,iBAAiB,CAAA;AAa7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAmPvD,KAAK,IAAI,GAAG;IACR,iBAAiB,EAAE,MAAM,CAAA;IACzB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,wBAAwB,EAAE,MAAM,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAA;AAID,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,IAAI,IA4LV,OAAO,KAAK;;;;6BAMjC,MAAM;;mBAIZ,MAAM;;;uCAkBkB,QAAQ,CAAC,wBAAwB,CAAC;sBAf3D,MAAM;kBACV;gBACF,IAAI;qCATS,MAAM;kBASL;aACjB;+BACkB,MAAM;;;EAuKpC"}