tungsten 0.1.6 → 0.1.24

package/dist/babelPlugins/BabelTransformComponentStyles.js

@@ -0,0 +1,383 @@
+// BabelTransformComponentStyles
+// exports MakeBabelTransformComponentStyles (function)
+//
+// runs preprocessors (.e.g SASS, SCSS, LESS) on component
+// stylesheets, scopes names, and converts it into an object
+// that can be applied to component output at runtime
+// (I think)
+import fs from 'fs';
+import { join, dirname, basename, sep, relative } from 'path';
+import * as sass from 'sass';
+import postcss from 'postcss';
+import { mapToArray as objectMapToArray } from 'sxy-lib/objects.js';
+import { TransformCssNames } from "../postcssPlugins/TransformCssNames.js";
+import { CssNames } from "../CssNames.js";
+//const CSSModulesSync = require('postcss-modules-sync').default
+import { watch } from "../watch.js";
+import slash from 'slash';
+import { resolveSassImport } from 'tungsten/build/resolveSassScssImports.js';
+import { sassImportParser } from 'tungsten/build/sassImportParser.js';
+import { modifySassImports } from 'tungsten/build/modifySassImports.js';
+import { scssImportParserChatgpt } from 'tungsten/build/scssImportParserChatgpt.js';
+import { errorOut } from 'tungsten';
+import { fixImportsInSassErrorMessage } from "./fixImportsInSassErrorMessage.js";
+class StyleAssistant {
+  static toCss(data, fullFile, fullSourceFile, importBase) {
+    return {
+      css: data,
+      dependencies: []
+    };
+  }
+}
+class Css extends StyleAssistant {
+  static toCss(data) {
+    const dependencies = [];
+    return {
+      css: data,
+      dependencies
+    };
+  }
+}
+// function getSassScssImporter(fullSourceFile: string, importBase: string, dependencies: string[]): sass.Importer { 
+//     return {
+//         canonicalize(url: string, context): URL {
+//             console.log(`importer->canonicalize '${url}' in ${fullSourceFile}`)
+//             return new URL(url)
+//         },
+//         load(url: URL): sass.ImporterResult | null {
+//             console.log(`importer->load '${url}' in ${fullSourceFile}`)
+//             const target = resolveScssImport(String(url), fullSourceFile, importBase)
+//             console.log('import resolved target:', target)
+//             const contents = readFileSync(target, 'utf-8')
+//             console.log('file contents', contents)
+//             // this url is only relative
+//             dependencies.push(target)
+//             return {
+//                 contents: readFileSync(target, 'utf-8'),
+//                 syntax: target.endsWith('.sass') ? 'indented' : 'scss', // could the import be a CSS file?
+//             }
+//         }
+//     }
+// }
+// function getSassScssFileImporter(fullSourceFile: string, importBase: string, dependencies: string[]) {
+//     return {
+//         findFileUrl(url: string) {
+//             //console.log('findFileUrl', url)
+//             return new URL(url)
+//         }
+//     }
+// }
+function sassScssToCss(data, fullFile, fullSourceFile, importBase, syntax) {
+  //console.log(`Component SCSS in ${fullSourceFile} to css`)
+  const dependencies = new Set();
+  const imports = syntax === 'indented' ? sassImportParser(data) : scssImportParserChatgpt(data);
+  const importsMap = [];
+  //if (sassImportResolution === 'js') {
+  for (const i of imports) {
+    const resolved = resolveSassImport(i.target, fullSourceFile, importBase);
+    //console.log('relative', fullSourceFile, resolved, slash(relative(dirname(fullSourceFile), resolved)))
+    dependencies.add(resolved);
+    importsMap.push({
+      ...i,
+      to: slash(relative(dirname(fullSourceFile), resolved)) // should we use absolute or relative?
+    });
+  }
+  data = modifySassImports(data, importsMap);
+  //} else {
+  // standard import resolution
+  //}
+  const compileOptions = {
+    syntax,
+    url: new URL('file:' + fullSourceFile)
+    //loadPaths: [importBase],
+    //importer: getSassScssImporter(fullSourceFile, importBase, dependencies)
+  };
+  let compileResult;
+  try {
+    compileResult = sass.compileString(data, compileOptions);
+  } catch (e) {
+    const {
+      message,
+      foundImportError
+    } = fixImportsInSassErrorMessage(e.message, importsMap);
+    if (foundImportError) errorOut(`Tungsten uses modified import resolution for SASS. Relative imports must start with ./ or ../`);
+    e.message = message;
+    throw e;
+  }
+  const {
+    css
+  } = compileResult;
+  return {
+    // seem to accept a file location, which is needed for imports
+    css,
+    dependencies: Array.from(dependencies)
+  };
+}
+class Sass extends StyleAssistant {
+  static toCss(data, fullFile, fullSourceFile, importBase) {
+    return sassScssToCss(data, fullFile, fullSourceFile, importBase, 'indented');
+  }
+}
+class Scss extends StyleAssistant {
+  static toCss(data, fullFile, fullSourceFile, importBase) {
+    return sassScssToCss(data, fullFile, fullSourceFile, importBase, 'scss');
+  }
+}
+function triggerDependers(styleDependers, dependers) {
+  //console.log('triggerDependers')
+  //console.log('styleDependers', styleDependers)
+  //console.log('dependers', dependers)
+  const time = new Date();
+  for (const depender of dependers) {
+    // bump the updated time on the file to make babel/webpack reprocess
+    fs.utimesSync(depender, time, time);
+    if (depender in styleDependers) {
+      // check for further dependers, tree like, recursively
+      triggerDependers(styleDependers, styleDependers[depender]);
+    }
+  }
+}
+function cssToLocalClassNames(data, file, moduleName) {
+  //console.log('cssToLocalClassNames')
+  const names = new CssNames(moduleName);
+  const transformedCss = postcss([TransformCssNames({
+    //generateScopedName: opts.classNameFormat,
+    moduleName,
+    outNames: names
+  })]).process(data, {
+    from: file
+  }).css;
+  return {
+    names,
+    transformedCss
+  };
+}
+//// The babel plugin creator that will be called in the babel config, returing the babel plugin
+//// Has side effects!!
+export function MakeBabelTransformComponentStyles(opts) {
+  opts.classNameFormat = 'classNameFormat' in opts ? opts.classNameFormat : '';
+  opts.cssOutputFile = 'cssOutputFile' in opts ? opts.cssOutputFile : '';
+  opts.cssModulesOutputDir = 'cssModulesOutputDir' in opts ? opts.cssModulesOutputDir : '';
+  //opts.functionNames = ('functionNames' in opts) ? opts.functionNames : ['Sass']
+  const languages = {
+    'Css': Css,
+    'Sass': Sass,
+    'Scss': Scss
+    //'Less': Less,
+  };
+  const watchStyles = opts.cssOutputFile || opts.cssModulesOutputDir;
+  // should this code be moved to babel - pre?
+  // prepare the css file by creating a blank file or clearing the existing file
+  if (opts.cssOutputFile) {
+    // create the folder the css files exists in if needed
+    const outDir = dirname(opts.cssOutputFile);
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, {
+      recursive: true
+    });
+    fs.writeFileSync(opts.cssOutputFile, '');
+  }
+  const styleDependers = {};
+  // start watching for changes to sass files
+  if (watchStyles) {
+    watch({
+      dir: opts.projectAbsSourceDir,
+      patterns: ['**/*.sass', '**/*.scss'
+      //'**/*.less'
+      ],
+      handler: (filename /*, event*/) => {
+        //filename = slash(filename)
+        //console.log('[watch event for style file', filename)
+        //console.log('styleDependers', styleDependers)
+        // do we need to respond differently to any specific events?
+        // unsure
+        //const fullFilename = process.cwd() + '\\' + filename.replaceAll('/', '\\')
+        // a file may import a filename without an extension. This could resolve to either a .sass or .scss file
+        // and which one is resolves too may change over time, if files are created and removed.
+        // its an error for an import to resolve to both a .sass and .scss file
+        // we want to trigger an update if the import could resolve to this file
+        const filenameWithoutExtension = filename.slice(0, filename.lastIndexOf('.'));
+        if (filename in styleDependers) {
+          //console.log(filename, 'is in styleDependers list')
+          triggerDependers(styleDependers, styleDependers[filename]);
+        }
+        //console.log('now looking for', filenameWithoutExtension)
+        if (filenameWithoutExtension in styleDependers) {
+          //console.log(filenameWithoutExtension, '(without extension) is in styleDependers list')
+          triggerDependers(styleDependers, styleDependers[filenameWithoutExtension]);
+        }
+      }
+    });
+  }
+  //const files = {}
+  const stylesheets = {};
+  const individualFolderName = 'i';
+  function getModuleName(relFilePath, index) {
+    //console.log('getModuleName filename', filename)
+    //let filePath = filename.slice(process.cwd().length +1)
+    //filePath = filePath.slice((projectConfig.reactAppLocation).length + 1)
+    //console.log('projectCodeBase', opts.projectCodeBase)
+    const fileName = basename(relFilePath);
+    const name = fileName.split('.')[0];
+    const parts = relFilePath.split(sep);
+    if (name === 'index') {
+      parts.pop();
+    } else {
+      parts[parts.length - 1] = name;
+    }
+    if (index > 1) parts.push(index);
+    const moduleName = parts.join('-');
+    return moduleName;
+  }
+  function writeOutIfNeeded(css, names, opts) {
+    // write a specific module file
+    if (typeof opts.cssOutputFile === 'string' && opts.cssOutputFile !== '') {
+      const modulesFolder = join(dirname(opts.cssOutputFile), individualFolderName);
+      if (!fs.existsSync(modulesFolder)) fs.mkdirSync(modulesFolder, {
+        recursive: true
+      });
+      fs.writeFileSync(join(modulesFolder, stylesheets[names.moduleName]), `${css}\n`);
+    }
+    //const mode = (isDev) ? 'new' : 'old'
+    const mode = 'new';
+    if (typeof opts.cssOutputFile === 'string' && opts.cssOutputFile !== '') {
+      //console.log('css:', css)
+      if (mode === 'new') {
+        // write a bunch of @import statements
+        fs.writeFileSync(opts.cssOutputFile, Object.values(stylesheets).map(file => `@import "${individualFolderName}/${file}";`).join('\n'));
+      } else {
+        const startLine = `/*Module ${names.moduleName}*/`;
+        const endLine = `/*End Module ${names.moduleName}*/`;
+        // strip the old module code from the css file, if it exists
+        // maybe this is inefficient
+        const fileLines = fs.readFileSync(opts.cssOutputFile, 'utf-8').split('\n');
+        let allow = true;
+        let startLineFound = false;
+        let endLineFound = false;
+        const newLines = [];
+        for (const line of fileLines) {
+          if (line === startLine) {
+            startLineFound = true;
+            allow = false;
+          }
+          if (allow) newLines.push(line);
+          if (line === endLine) {
+            if (startLineFound) {
+              endLineFound = true;
+              allow = true;
+            }
+          }
+        }
+        if (endLineFound) {
+          fs.writeFileSync(opts.cssOutputFile, newLines.join('\n'));
+        }
+        fs.appendFileSync(opts.cssOutputFile, `${startLine}\n` + `${css}\n` + `${endLine}\n`);
+      }
+    }
+  }
+  let index = 1;
+  // return the babel plugin
+  return function BabelTransformComponentStyles(babel) {
+    const t = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      pre(state) {
+        //state.__stylesheetIndex = 1
+        state.opts.stylesheetIndex = 1;
+        state.iteration = index++; // wanted to make this available inside visitors, but doesn't seem to be
+      },
+      visitor: {
+        TaggedTemplateExpression(path, state) {
+          //console.log('tte visitor')
+          //console.log('state', state)
+          // this this index as part of the scoping
+          const tte = path.node;
+          const tag = tte.tag;
+          if (tag.type === 'Identifier' && tag.name in languages) {
+            //if ( opts.functionNames.includes(tag.name) ) {
+            const tagName = tag.name; // eslint-disable-line no-type-assertion/no-type-assertion -- fine, TS narrowing from the 'in' check above isn't working here
+            //console.log('found stylesheet', tag.name)
+            const Assistant = languages[tagName];
+            const template = tte.quasi.quasis[0];
+            const rawStyles = template.value.raw;
+            //console.log('node', path.node)
+            //console.log('state.file.opts.filename', state.file.opts.filename)
+            const fullFilePath = slash(state.filename);
+            const relFilePath = fullFilePath.slice(opts.projectAbsCodeDir.length + 1);
+            const fullSourceFilePath = join(opts.projectAbsSourceDir, relFilePath);
+            //console.log('fullFilePath', fullFilePath)
+            //console.log('relFilePath', relFilePath)
+            //console.log('fullSourceFilePath', fullSourceFilePath)
+            //// transforming css
+            //// and writing to css files
+            // create a name based on the component file name and path
+            const moduleName = getModuleName(relFilePath, state.file.opts.stylesheetIndex);
+            //console.log('transforming to css')
+            // transform the CSS and find it's dependncies (if using a pre-processor)
+            const {
+              css,
+              dependencies
+            } = Assistant.toCss(rawStyles, fullFilePath, fullSourceFilePath, opts.projectAbsStyleImportDir);
+            //console.log('result,', css)
+            //////////////////// deps
+            //console.log(index, 'watchStyles', watchStyles)
+            if (watchStyles) {
+              // update the list of dependencies for the stylesheet watcher
+              //console.log(index, 'styleDependers', styleDependers)
+              // deps clearout
+              for (const file in styleDependers) {
+                //console.log(index, 'testing for', fullFilePath, 'in', styleDependers[file])
+                if (styleDependers[file].has(fullFilePath)) {
+                  //if (fullFilePath in styleDependers[file]) {
+                  //styleDependers[file].remove(fullFilePath)
+                  //console.log(index, 'found', fullFilePath)
+                  //console.log('removing it from the array')
+                  //arrayRemove(styleDependers[file], fullFilePath)
+                  styleDependers[file].delete(fullFilePath);
+                }
+              }
+              // add this file to the list of files depending on this file
+              for (let dep of dependencies) {
+                dep = slash(dep);
+                if (!(dep in styleDependers)) {
+                  //console.log('creating a set for dep:', dep)
+                  styleDependers[dep] = new Set();
+                }
+                //styleDependers[dep].push(fullFilePath)
+                styleDependers[dep].add(fullFilePath);
+              }
+            }
+            //////////////////// end deps
+            //console.log(index, 'after deps handling styleDependers', styleDependers)
+            const {
+              names,
+              transformedCss
+            } = cssToLocalClassNames(css, fullFilePath, moduleName);
+            stylesheets[moduleName] = moduleName + '.css';
+            writeOutIfNeeded(transformedCss, names, opts);
+            // increment for the next one
+            state.__stylesheetIndex++;
+            state.file.opts.stylesheetIndex++;
+            // We could remove the style property if it is not doing anything, but this could break application logic that depends on style existing
+            // if (count(names.tags) === 0 && count(names.classes) === 0) {       
+            //     path.parentPath.remove()// replaceWith(t.Identifier('undefined'))
+            //     return
+            // }
+            const props = [t.objectProperty(t.StringLiteral('moduleName'), t.StringLiteral(names.moduleName))];
+            if (names.tags !== undefined) props.push(t.objectProperty(t.StringLiteral('tags'), t.ObjectExpression(objectMapToArray(
+            // from sxy-standard library
+            names.tags, (key, value) => t.objectProperty(t.StringLiteral(key), t.StringLiteral(value))))));
+            if (names.classes !== undefined) props.push(t.objectProperty(t.StringLiteral('classes'), t.ObjectExpression(objectMapToArray(
+            // from sxy-standard library
+            names.classes, (key, value) => t.objectProperty(t.StringLiteral(key), t.StringLiteral(value))))));
+            const obj = t.ObjectExpression(props);
+            path.replaceWith(obj);
+          }
+        }
+      }
+    };
+  };
+}
+// export function MakeBabelTransformComponentStyles() {
+//     //
+// }

package/dist/babelPlugins/BabelTransformCssImport.d.ts

@@ -0,0 +1,14 @@
+import { Babel, NodePath } from './BabelTypes.js';
+import type { ImportDeclaration } from 'babel-types';
+import { BabelState } from './BabelState.type.js';
+type Opts = {
+    absCodeDir: string;
+};
+export declare function MakeBabelTransformCssImport(opts: Opts): (babel: Babel) => {
+    pre: (state: BabelState) => void;
+    visitor: {
+        ImportDeclaration: (path: NodePath<ImportDeclaration>) => void;
+    };
+};
+export {};
+//# sourceMappingURL=BabelTransformCssImport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCssImport.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCssImport.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAc,MAAM,iBAAiB,CAAA;AAE7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAIjD,KAAK,IAAI,GAAG;IACR,UAAU,EAAE,MAAM,CAAA;CACrB,CAAA;AACD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,WACH,KAAK;iBAKtB,UAAU;;kCAIO,QAAQ,CAAC,iBAAiB,CAAC;;EAuE7E"}

package/dist/babelPlugins/BabelTransformCssImport.js

@@ -0,0 +1,76 @@
+// BabelTransformCssImport
+// exports MakeBabelTransformComponentStyles (function)
+//
+// Converts imports of raw CSS files into a variable declaration
+// storing the location of the case file, e.g.
+// const stylesheet = 'assets/styles.css'
+// (I think)
+// I think this is done so that that value can be inserted into a
+// Stylesheet element, which can then add an HTML style tag referencing
+// that stylesheet
+import { dirname } from 'path';
+import slash from 'slash';
+export function MakeBabelTransformCssImport(opts) {
+  return function BabelTransformCssImport(babel) {
+    const t = babel.types;
+    //let projectDir
+    let filename;
+    return {
+      pre: function (state) {
+        filename = state.opts.filename;
+      },
+      visitor: {
+        ImportDeclaration: function (path /*, state*/) {
+          let location = path.node.source.value;
+          //.slice(2) // remove ./
+          if (location.endsWith('.css') || location.endsWith('.scss') || location.endsWith('.sass')) {
+            //console.log('found a css import in', filename)
+            //console.log('absCodeDir', opts.absCodeDir)
+            if (location.startsWith('./')) {
+              //console.log('dirname', dirname(filename.slice(opts.absCodeDir.length)))
+              let fileRelDir = slash(dirname(filename.slice(opts.absCodeDir.length)));
+              if (fileRelDir === '/') fileRelDir = '';
+              //console.log('dirname', fileRelDir)
+              //console.log('location without dot', location.slice(1))
+              location = fileRelDir + location.slice(1); // remove .
+              //console.log('new location', location)
+            }
+            const varName = path.node.specifiers[0].local.name;
+            const locationWithCssExt = location.slice(0, location.lastIndexOf('.')) + '.css';
+            const assignment = t.variableDeclaration('const', [t.variableDeclarator(t.identifier(varName), t.objectExpression([t.objectProperty(t.identifier('href'), t.stringLiteral(locationWithCssExt))]))]);
+            path.replaceWith(assignment);
+            // const baseDir = join(opts.projectDir, opts.codeDir)
+            // let importedFileLocations
+            // try {
+            //     importedFileLocations = calculateImportedStaticFileLocations(opts.projectDir, baseDir, state.filename, location)
+            // } catch (e) { 
+            //     if (e instanceof SxyFrameworkFileNotInBaseError) {
+            //         throw new TungstenError(
+            //             `SXY Framework, BabelTransformCssImport Error:`
+            //             + ` the file being processed does not appear to be in the code folder specified in your config`
+            //             + `\nFile being processed: ${state.filename}`
+            //             + `\nCode folder from config (or default): ${opts.codeDir}`
+            //             + `\nComplete base folder: ${baseDir}`
+            //         )
+            //     } else {
+            //         throw e
+            //     }
+            // }
+            // console.log('source', importedFileLocations.source)
+            // console.log('target', importedFileLocations.target)
+            // console.log('targetRel', importedFileLocations.targetRel)
+            // console.log('cwd', process.cwd())
+            // try {
+            //     mkdirSync(dirname(importedFileLocations.target), { recursive: true })
+            //     copyFileSync(importedFileLocations.source, importedFileLocations.target)
+            // } catch (e) {
+            //     console.log('Error copying: ', e)
+            // }
+          }
+        }
+      }
+      //post: function (state) {
+      //},
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformDependencyImportsCjs.d.ts

@@ -0,0 +1,26 @@
+import type * as BabelCore from '@babel/core';
+import { NodePath } from '@babel/core';
+type Babel = typeof BabelCore;
+import { ExportAllDeclaration, ExportNamedDeclaration, type CallExpression, type ImportDeclaration } from 'babel-types';
+import type { GetPackageDirForFile, GetPackageInfoForFile, GetExternalImportFinalImportLocation, GetCjsRelativeImportFinalImportLocation, GetFileFinalLocation } from './BabelTransformPackageImports.js';
+type Opts = {
+    nonEsmDeps: string[];
+};
+type Funcs = {
+    getPackageDirForFile: GetPackageDirForFile;
+    getPackageInfoForFile: GetPackageInfoForFile;
+    getExternalImportFinalImportLocation: GetExternalImportFinalImportLocation;
+    getCjsRelativeImportFinalImportLocation: GetCjsRelativeImportFinalImportLocation;
+    getFileFinalLocation: GetFileFinalLocation;
+};
+export declare function MakeBabelTransformDependencyImportsCjs(opts: Opts, funcs: Funcs): (babel: Babel) => {
+    pre(state: any): void;
+    visitor: {
+        ImportDeclaration: (path: NodePath<ImportDeclaration>) => void;
+        ExportNamedDeclaration: (path: NodePath<ExportNamedDeclaration>) => void;
+        ExportAllDeclaration: (path: NodePath<ExportAllDeclaration>) => void;
+        CallExpression(path: NodePath<CallExpression>): void;
+    };
+};
+export {};
+//# sourceMappingURL=BabelTransformDependencyImportsCjs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformDependencyImportsCjs.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformDependencyImportsCjs.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAc,MAAM,aAAa,CAAA;AAClD,KAAK,KAAK,GAAG,OAAO,SAAS,CAAC;AAM9B,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAA0B,KAAK,cAAc,EAAmB,KAAK,iBAAiB,EAAsB,MAAM,aAAa,CAAA;AAIpL,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,oCAAoC,EAAE,uCAAuC,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AASzM,KAAK,IAAI,GAAG;IACR,UAAU,EAAE,MAAM,EAAE,CAAA;CACvB,CAAA;AAED,KAAK,KAAK,GAAG;IACT,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,qBAAqB,EAAE,qBAAqB,CAAA;IAC5C,oCAAoC,EAAE,oCAAoC,CAAA;IAC1E,uCAAuC,EAAE,uCAAuC,CAAA;IAChF,oBAAoB,EAAE,oBAAoB,CAAA;CAC7C,CAAA;AAED,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,WACjB,KAAK;eAoC5C,GAAG;;kCAQyB,QAAQ,CAAC,iBAAiB,CAAC;uCAKtB,QAAQ,CAAC,sBAAsB,CAAC;qCAOlC,QAAQ,CAAC,oBAAoB,CAAC;6BAO/C,QAAQ,CAAC,cAAc,CAAC;;EAkD5D"}

package/dist/babelPlugins/BabelTransformDependencyImportsCjs.js

@@ -0,0 +1,117 @@
+// BabelTransformDependencyImportsCjs
+// exports MakeBabelTransformDependencyImportsCjs (function)/
+// Arg 1: opts {
+//     nonEsmDeps: string[] (should it be an obj?) -- a list of CJS/presumed CJS direct dependencies to let us switch between ESM (defualt) and CJS handling
+// }
+// Arg 2: funcs {
+//    funcs from the parent to do various things.
+//    passed in from the parent because this allows them to use a central cache
+// }
+import { dirname, relative } from 'path';
+import slash from 'slash';
+import { isBareImport } from "./isBareImport.js";
+import { cliWarn } from "../cliOutput.js";
+import { warn } from "../output.js";
+export function MakeBabelTransformDependencyImportsCjs(opts, funcs) {
+  return function BabelTransformDependencyImportsCjs(babel) {
+    const t = babel.types;
+    let filename;
+    let futureFilename;
+    let packageDir;
+    function getNewLocation(location) {
+      //console.log('MakeBabelTransformDependencyImportsCjs', 'getNewLocation', location)
+      if (isBareImport(location)) {
+        //console.log('***')
+        const final = funcs.getExternalImportFinalImportLocation(location, filename, packageDir, 'cjs');
+        if (final === location) {
+          // perhaps a node module
+          return [false, null];
+        }
+        let rel = slash(relative(dirname(futureFilename), final));
+        if (!rel.startsWith('../')) rel = './' + rel;
+        return [true, rel];
+      } else {
+        //cliWarn(`cjs rel`, location, 'from', filename)
+        const final = funcs.getCjsRelativeImportFinalImportLocation(location, filename /*, packageDir*/);
+        //console.log('cjs rel final', final)
+        if (final === location) {
+          // perhaps a node module
+          cliWarn(`cjs final was unchanged`);
+          return [false, null];
+        }
+        let rel = slash(relative(dirname(futureFilename), final));
+        if (!rel.startsWith('../')) rel = './' + rel;
+        return [true, rel];
+      }
+    }
+    //let require
+    return {
+      pre(state) {
+        filename = state.opts.filename;
+        //console.log('processing file:', filename)
+        const packageInfo = funcs.getPackageInfoForFile(filename);
+        packageDir = packageInfo.packageDir;
+        futureFilename = funcs.getFileFinalLocation(filename, packageInfo);
+      },
+      visitor: {
+        ImportDeclaration: function (path) {
+          const location = path.node.source.value;
+          const [transform, newLocation] = getNewLocation(location);
+          if (transform) path.node.source.value = newLocation;
+        },
+        ExportNamedDeclaration: function (path) {
+          if (path.node.source) {
+            const location = path.node.source.value;
+            const [transform, newLocation] = getNewLocation(location);
+            if (transform) path.node.source.value = newLocation;
+          }
+        },
+        ExportAllDeclaration: function (path) {
+          if (path.node.source) {
+            const location = path.node.source.value;
+            const [transform, newLocation] = getNewLocation(location);
+            if (transform) path.node.source.value = newLocation;
+          }
+        },
+        CallExpression(path) {
+          const callee = path.node.callee;
+          //console.log('callee', callee)
+          // console.log('callee', path.node.callee)
+          if (callee.type === 'Import') {
+            callee;
+            //console.log('import call ex', path.node)
+            const arg0 = path.node.arguments[0];
+            //console.log('first arg', arg0)
+            if (arg0.type === 'StringLiteral') {
+              const location = arg0.value;
+              const [transform, newLocation] = getNewLocation(location);
+              if (transform) path.node.arguments[0] = t.StringLiteral(newLocation);
+            } else if (arg0.type === 'Identifier') {
+              warn('import arg 0 is an identifier', arg0);
+              warn('Handling this has not been implemented yet');
+            } else {
+              warn(`MakeBabelTransformDependencyImportsCjs warning:` + ` import call first argument is an unhandled type:` + ` ${arg0.type}`);
+            }
+          } else if (callee.type === 'Identifier' && callee.name === 'require') {
+            //console.log('require call ex', path.node)
+            const arg0 = path.node.arguments[0];
+            //console.log('first arg', arg0)
+            if (arg0.type === 'StringLiteral') {
+              const location = arg0.value;
+              //console.log(chalk.red`found a require`, location)
+              const [transform, newLocation] = getNewLocation(location);
+              //console.log(transform, newLocation)
+              if (transform) path.node.arguments[0] = t.StringLiteral(newLocation);
+            } else if (arg0.type === 'Identifier') {
+              warn('require arg 0 is an identifier', arg0);
+              warn('Handling this has not been implemented yet');
+              warn(`In file ${filename}`);
+            } else {
+              warn(`MakeBabelTransformDependencyImportsCjs warning:` + ` require call first argument is an unhandled type:` + ` ${arg0.type}`);
+            }
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformDependencyImportsEsm.d.ts

@@ -0,0 +1,26 @@
+import type * as BabelCore from '@babel/core';
+import { NodePath } from '@babel/core';
+type Babel = typeof BabelCore;
+import { CallExpression, ExportAllDeclaration, ExportNamedDeclaration, ImportDeclaration } from '@babel/types';
+import type { GetPackageDirForFile, GetPackageInfoForFile, GetExternalImportFinalImportLocation, GetFileFinalLocation, MakeCjsEntryFile } from './BabelTransformPackageImports.js';
+type Opts = {
+    nonEsmDeps: string[];
+};
+type Funcs = {
+    getPackageDirForFile: GetPackageDirForFile;
+    getPackageInfoForFile: GetPackageInfoForFile;
+    getExternalImportFinalImportLocation: GetExternalImportFinalImportLocation;
+    getFileFinalLocation: GetFileFinalLocation;
+    makeCjsEntryFile: MakeCjsEntryFile;
+};
+export declare function MakeBabelTransformDependencyImportsEsm(opts: Opts, funcs: Funcs): (babel: Babel) => {
+    pre(state: any): void;
+    visitor: {
+        ImportDeclaration(path: NodePath<ImportDeclaration>): void;
+        ExportNamedDeclaration: (path: NodePath<ExportNamedDeclaration>) => void;
+        ExportAllDeclaration: (path: NodePath<ExportAllDeclaration>) => void;
+        CallExpression(path: NodePath<CallExpression>): void;
+    };
+};
+export {};
+//# sourceMappingURL=BabelTransformDependencyImportsEsm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformDependencyImportsEsm.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformDependencyImportsEsm.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAc,MAAM,aAAa,CAAA;AAClD,KAAK,KAAK,GAAG,OAAO,SAAS,CAAC;AAO9B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAI9G,OAAO,KAAK,EACR,oBAAoB,EAAE,qBAAqB,EAAE,oCAAoC,EACjF,oBAAoB,EAAE,gBAAgB,EACzC,MAAM,mCAAmC,CAAA;AAK1C,KAAK,IAAI,GAAG;IACR,UAAU,EAAE,MAAM,EAAE,CAAA;CACvB,CAAA;AAED,KAAK,KAAK,GAAG;IACT,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,qBAAqB,EAAE,qBAAqB,CAAA;IAC5C,oCAAoC,EAAE,oCAAoC,CAAA;IAC1E,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,gBAAgB,EAAE,gBAAgB,CAAA;CACrC,CAAA;AAED,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,WACjB,KAAK;eAwB5C,GAAG;;gCAOc,QAAQ,CAAC,iBAAiB,CAAC;uCAMX,QAAQ,CAAC,sBAAsB,CAAC;qCAOlC,QAAQ,CAAC,oBAAoB,CAAC;6BAO/C,QAAQ,CAAC,cAAc,CAAC;;EA2B5D"}