tungsten 0.2.1 → 0.2.3

package/dist/build/compileJavascript.js

@@ -0,0 +1,190 @@
+import { join, dirname } from 'path';
+import chokidar from 'chokidar';
+import { transformFileAsync as babeltransformFileAsync } from '@babel/core';
+import fs, { promises as fsPromises } from 'fs';
+import slash from 'slash';
+import serializeJavascript from 'serialize-javascript';
+import { globby } from 'globby';
+import { packagesCacheFolder } from "../settings.js";
+import { makeBabelUserDevConfig } from "./makeBabelUserDevConfig.js";
+import { makeBabelUserProdConfig } from "./makeBabelUserProdConfig.js";
+import { cliOut, cliLog, cliError } from "../cliOutput.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { TungstenError } from "../TungstenError.js";
+import { getFrameworkDir } from "../getFrameworkDir.js";
+///// needs work to work in prod mode
+///// see babel config
+export async function compileJavascript(projectDir, appConfig, codeLocation, sourceLocation, styleImportBase, buildLocation, buildCodeLocation, mode) {
+  cliOut(`Compiling app code`);
+  let dependencyGraphDir;
+  let dependencyGraphLocation;
+  let oldDependencyGraph;
+  let dependencyGraph;
+  let importAliases;
+  let promises;
+  let config;
+  if (mode === 'dev') {
+    dependencyGraphDir = join(projectDir, packagesCacheFolder);
+    dependencyGraphLocation = join(dependencyGraphDir, '.dependency-graph.js');
+    oldDependencyGraph = {};
+    dependencyGraph = {};
+    importAliases = {};
+    promises = [];
+    config = makeBabelUserDevConfig(projectDir, codeLocation, sourceLocation, styleImportBase, buildLocation, buildCodeLocation, oldDependencyGraph, dependencyGraph, importAliases, promises);
+  } else {
+    config = makeBabelUserProdConfig(projectDir, codeLocation, sourceLocation, styleImportBase);
+  }
+  config.root = getFrameworkDir();
+  // compile with the API
+  const codeLocationLength = codeLocation.length + 1;
+  const transformPromises = [];
+  async function transformFile(file) {
+    console.log('transforming file', file);
+    try {
+      let rel = file.slice(codeLocationLength);
+      if (rel.endsWith('.jsx')) rel = rel.slice(0, -1);
+      const dest = join(buildCodeLocation, rel);
+      const result = await babeltransformFileAsync(file, config);
+      if (result === null) throw new TungstenError(`Err: babel transform on file ${file} returned null`);
+      const {
+        code
+      } = result;
+      if (code === null || code === undefined) {
+        throw new TungstenError(`Err: code from babel transform on file ${file} was null or undefined: ${typeof code}`);
+      }
+      await fsPromises.mkdir(dirname(dest), {
+        recursive: true
+      });
+      //// Using the sync version here, because the promise version keeps bugging out - node bug?
+      //await fsPromises.writeFile(dest, code)
+      fs.writeFileSync(dest, code);
+    } catch (e) {
+      cliError(`Tungsten: Error transforming project file ${file}`);
+      cliLog(e);
+      //throw new TungstenError(`compileJavascript() error: error when compiling application file ${e}`)
+    }
+  }
+  async function copyFile(file) {
+    try {
+      let rel = file.slice(codeLocationLength);
+      if (rel.endsWith('.jsx')) rel = rel.slice(0, -1);
+      const dest = join(buildCodeLocation, rel);
+      await fsPromises.mkdir(dirname(dest), {
+        recursive: true
+      });
+      //// Using the sync version here, because the promise version keeps bugging out - node bug?
+      await fsPromises.copyFile(file, dest);
+    } catch (e) {
+      cliError(`Tungsten: Error copying file ${file}`);
+      cliError(e);
+      //throw new TungstenError(`compileJavascript() error: error when compiling application file ${e}`)
+    }
+  }
+  async function deleteFile(file) {
+    try {
+      let rel = file.slice(codeLocationLength);
+      if (rel.endsWith('.jsx')) rel = rel.slice(0, -1);
+      const dest = join(buildCodeLocation, rel);
+      await fsPromises.unlink(dest);
+    } catch (e) {
+      cliError(`Tungsten: Error deleting file ${file}`);
+      cliError(e);
+      //throw new TungstenError(`compileJavascript() error: error when compiling application file ${e}`)
+    }
+  }
+  // get a list of files
+  const watchGlob = slash(`${codeLocation}/**/*.js{,x}`);
+  const ignored = [];
+  if (appConfig.ignoreDirs) {
+    ignored.push(...appConfig.ignoreDirs.map(folder => slash(`${codeLocation}/${folder}/**`)));
+  }
+  if (appConfig.ignorePatterns) {
+    if (Array.isArray(appConfig.ignorePatterns)) {
+      for (const pattern of appConfig.ignorePatterns) {
+        ignored.push(pattern);
+      }
+    } else {
+      ignored.push(appConfig.ignorePatterns);
+    }
+  }
+  if (appConfig.exclude !== undefined) ignored.push(slash(`${codeLocation}/${appConfig.exclude}`));
+  //console.log('appConfig', appConfig)
+  //console.log('ignored', ignored)
+  //cliWarn(watchGlob)
+  //cliWarn('IGNORE')
+  //cliWarn(JSON.stringify(ignored))
+  /// need to do an initial build before watching
+  // not sure what glob matcher chokidar uses
+  const paths = await globby([watchGlob, ...ignored.map(x => `!${x}`)]);
+  paths.forEach(file => {
+    transformPromises.push(transformFile(file));
+  });
+  await Promise.all(transformPromises);
+  const watcher = chokidar.watch(watchGlob, {
+    ignored
+    //useFsEvents: false
+  });
+  watcher.on('all', async (event, file) => {
+    file = slash(file);
+    if (event === 'add') {
+      transformFile(file);
+    }
+    if (event === 'change') {
+      transformFile(file);
+    }
+  });
+  let copyWatcher = null;
+  if (appConfig.copy !== undefined) {
+    const copyWatcherOptions = {};
+    if (appConfig.copyExclude !== undefined) copyWatcherOptions.ignored = appConfig.copyExclude;
+    copyWatcher = chokidar.watch(appConfig.copy, copyWatcherOptions);
+    copyWatcher.on('all', async (event, file) => {
+      file = slash(file);
+      if (event === 'add') {
+        copyFile(file);
+      }
+      if (event === 'change') {
+        copyFile(file);
+      }
+      if (event === 'unlink' || event === 'unlinkDir') {
+        deleteFile(file);
+      }
+    });
+  }
+  return new Promise(resolve => {
+    const awaiting = new Map([[watcher, true]]);
+    if (copyWatcher) awaiting.set(copyWatcher, true);
+    watcher.on('ready', async () => {
+      //cliNews('App Built')
+      if (mode === 'dev') {
+        await Promise.all(promises);
+        if (!fs.existsSync(dependencyGraphDir)) {
+          fs.mkdirSync(dependencyGraphDir, {
+            recursive: true
+          });
+        }
+        fs.writeFileSync(dependencyGraphLocation, `export const graph = ${serializeJavascript(dependencyGraph)}`);
+      }
+      awaiting.delete(watcher);
+      if (awaiting.size === 0) {
+        resolve({
+          watcher,
+          copyWatcher,
+          importAliases
+        });
+      }
+    });
+    if (copyWatcher !== null) {
+      const validCopyWatcher = copyWatcher;
+      copyWatcher.on('ready', () => {
+        awaiting.delete(validCopyWatcher);
+        if (awaiting.size === 0) {
+          resolve({
+            watcher,
+            copyWatcher,
+            importAliases
+          });
+        }
+      });
+    }
+  });
+}

package/dist/build/compilePackages.d.ts

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

package/dist/build/compilePackages.d.ts.map

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

package/dist/build/compilePackages.js

@@ -0,0 +1,89 @@
+// import dependencyTree from 'sxy-dependency-tree'
+// import { globby } from 'globby'
+// import slash from 'slash'
+// import { existsSync, promises as fsPromises } from 'fs'
+// import { join } from 'path'
+// import { createRequire } from 'module'
+export {};
+// import type { ProcessPackageResults } from './ProcessPackageResults.js'
+// import type { PackagesCacheInfo } from './PackagesCacheInfo.js'
+// import { processPackage } from './processPackage.js'
+// import { 
+//     packagesCacheFolder, packagesCacheInfoName, assetsFolder, componentCssFolder, packagesFolder, staticFolder
+// } from '../settings.js'
+// import { cliError } from '../cliOutput.js'
+// const require = createRequire(import.meta.url)
+// type CompilePackagesResult = {
+//     packages: ProcessPackageResults
+// }
+// //// UNUSED
+// export function compilePackages(projectDir: string, buildLocation: string): Promise<CompilePackagesResult> {
+//     return new Promise( (resolve, reject) => {
+//         console.log('start compiling packages')
+//         // should we clear out the packages folders, to remove any packages that are no longer used?
+//         //or should we check at the end, removing any excess?
+//         projectDir = slash(projectDir) // convert backslashes on windows to forward slashes
+//         // create a .packages folder if it doesn't already exist??
+//         const packagesLocation = `${buildLocation}/${packagesFolder}`
+//         if ( ! existsSync(packagesLocation) ) fsPromises.mkdir(packagesLocation)
+//         // get info about the packages cache
+//         const packagesCacheInfoLocation = join(projectDir, packagesCacheFolder, packagesCacheInfoName)
+//         let packagesCacheInfo: PackagesCacheInfo
+//         try {
+//             packagesCacheInfo = require(packagesCacheInfoLocation)
+//         } catch (e) {
+//             cliError('error loading package cache info', e)
+//             packagesCacheInfo = {}
+//         }
+//         buildLocation = slash(buildLocation) // convert backslashes on windows to forward slashes
+//         const glob = [
+//             `${buildLocation}/**/*.js`,
+//             `!${buildLocation}/${assetsFolder}/**/*`, // these folders are already ignored unless dot is set to true
+//             `!${buildLocation}/${componentCssFolder}/**/*`, //
+//             `!${buildLocation}/${packagesFolder}/**/*`, //
+//             `!${buildLocation}/${staticFolder}/**/*` //
+//         ]
+//         //console.log('searching in ', glob)
+//         globby(glob, { dot: true }).then( async (matches) => {
+//             const projectNodeModulesLocation = `${projectDir}/node_modules/`
+//             const projectNodeModulesLocationLength = projectNodeModulesLocation.length
+//             const packageDependencies: string[] = []
+//             for ( const file of matches ) {
+//                 const nonExistent: string[] = []
+//                 const dependencies = dependencyTree.toList({
+//                     filename: file,
+//                     directory: projectDir,
+//                     nonExistent,
+//                 })
+//                 for ( let dependency of dependencies ) {
+//                     dependency = slash(dependency) // convert backslashes on windows to forward slashes
+//                     if (dependency.startsWith(projectNodeModulesLocation)) {
+//                         if ( ! packageDependencies.includes(dependency) ) {
+//                             packageDependencies.push(dependency)
+//                         }
+//                     }
+//                 }
+//             }
+//             const packages: string[] = []
+//             for ( const pDependency of packageDependencies) {
+//                 const endPart = pDependency.slice(projectNodeModulesLocationLength)
+//                 const packageName = endPart.split('/')[0]!
+//                 if (packageName === 'tungsten') continue
+//                 if ( ! packages.includes(packageName) ) {
+//                     packages.push(packageName)
+//                 }
+//             }
+//             const results: ProcessPackageResults = []
+//             for (const p of packages) {
+//                 results.push( await processPackage(projectDir, packagesCacheInfo, p, buildLocation) )
+//             }
+//             const packagesLocation = `${buildLocation}/${packagesFolder}`
+//             fsPromises.writeFile(join(packagesLocation, '.sxy-packages-stats'), JSON.stringify(results))
+//             fsPromises.writeFile(packagesCacheInfoLocation, JSON.stringify(packagesCacheInfo))
+//             console.log('finishing compiling packages')
+//             resolve( {
+//                 packages: results
+//             } )
+//         } )
+//     })
+// }

package/dist/build/compileStyles.d.ts

@@ -0,0 +1,3 @@
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+export declare function compileStyles(projectDir: string, config: FrameworkConfigComplete, styleImportBase: string, buildLocation: string): Promise<unknown>;
+//# sourceMappingURL=compileStyles.d.ts.map

package/dist/build/compileStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileStyles.d.ts","sourceRoot":"","sources":["../../src/build/compileStyles.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAiOpE,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,oBA+EhI"}

package/dist/build/compileStyles.js

@@ -0,0 +1,241 @@
+import slash from 'slash';
+import chokidar from 'chokidar';
+import { join, dirname, resolve } from 'path';
+import { promises as fsPromises, utimesSync } from 'fs';
+import * as sass from 'sass';
+import { staticFolder } from "../settings.js";
+import { cliError, cliOut } from "../cliOutput.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { throwError } from "../throwError.js";
+import { resolveSassImport, resolveScssImport } from "./resolveSassScssImports.js";
+function debug(...texts) {
+  //console.log(...texts)
+}
+function arrayToObjectTrue(array) {
+  return array.reduce((obj, value) => {
+    obj[value] = true;
+    return obj;
+  }, {});
+}
+function sassToCss(data, file, importBase) {
+  try {
+    return sass.renderSync({
+      data,
+      file,
+      indentedSyntax: true,
+      importer: url => {
+        return {
+          file: resolveSassImport(url, file, importBase)
+        };
+      }
+    }).css.toString();
+  } catch (error) {
+    if (error instanceof Error) {
+      return error;
+    } else {
+      // throw not return because this is unexpected
+      throw new Error(`Error returned from sass compilation was not an Error. Type: ${typeof error}, value: ${String(error)}`);
+    }
+  }
+}
+function scssToCss(data, file, importBase) {
+  try {
+    return sass.renderSync({
+      data,
+      file,
+      importer: url => {
+        return {
+          file: resolveScssImport(url, file, importBase)
+        };
+      }
+    }).css.toString();
+  } catch (error) {
+    if (error instanceof Error) {
+      return error;
+    } else {
+      // throw not return because this is unexpected
+      throw new Error(`Error returned from sass compilation was not an Error. Type: ${typeof error}, value: ${String(error)}`);
+    }
+  }
+}
+function findSxssDependencies(data, file, regex, extension) {
+  // matchAll seems to return an iterator or something
+  // [...xxx] converts it to a plain array
+  let results = [...data.matchAll(regex)]
+  // the matches group is on position 1, so we map to get just the match group
+  .map(x => x[1]); // eslint-disable-line no-type-assertion/no-type-assertion
+  if (extension === '.sass') results = results.map(dep => {
+    if ((dep.startsWith(`'`) || dep.startsWith(`"`)) && dep.endsWith(dep[0])) {
+      return dep.slice(1, -1);
+    } else {
+      return dep;
+    }
+  });
+  results = results.map(x => x.slice(-5) === extension ? x : x + extension);
+  const dir = dirname(file);
+  //results = results.map( dep => resolve(dep, { paths: resolvePaths }) )
+  results = results.map(dep => {
+    //console.log('resolve', join(dir, dep))
+    return slash(resolve(join(dir, dep)));
+  });
+  return results;
+}
+function findSassDependencies(data, file) {
+  const regex = /@import\s+([^\n\r]+)/g;
+  const extension = '.sass';
+  return findSxssDependencies(data, file, regex, extension);
+}
+function findScssDependencies(data, file) {
+  const regex = /@import\s+['"]([^'"\s]+)['"]\s*;/g;
+  const extension = '.scss';
+  return findSxssDependencies(data, file, regex, extension);
+}
+function fileName(p) {
+  return p.substring(p.lastIndexOf('/') + 1);
+}
+function getDependers(dependersChart, file, originalFile) {
+  const result = {};
+  debug('dependers for', file);
+  for (const depender in dependersChart[file]) {
+    debug(fileName(file), '->', fileName(depender));
+    if (depender === file) {
+      throwError('compileStyles -> getDependers()', 'You have a dependency loop, ${file} depends on itself.');
+    }
+    result[depender] = true;
+    const subDependers = getDependers(dependersChart, depender, originalFile);
+    for (const subDepender in subDependers) {
+      if (subDepender === file) {
+        throwError('getDependers() ', 'You have a dependency loop, ${file} depends on itself.');
+      }
+      result[subDepender] = true;
+    }
+  }
+  debug('-');
+  return result;
+}
+function bumpDependers(dependersChart, file) {
+  const dependers = getDependers(dependersChart, file, file);
+  const time = new Date();
+  for (const depender in dependers) {
+    utimesSync(depender, time, time);
+  }
+}
+async function processAndCopyFile(sourceLocation, targetLocation, filePathFull, styleImportBase, cssFiles, cssDependencies, cssDependers) {
+  const relFile = filePathFull.slice(sourceLocation.length + 1);
+  const targetRelFile = relFile.slice(0, relFile.lastIndexOf('.')) + '.css';
+  const target = join(targetLocation, targetRelFile);
+  // create the folder if needed
+  await fsPromises.mkdir(dirname(target), {
+    recursive: true
+  });
+  //// !!!! need to check for classes using cssFiles
+  //// but it would have to watch for file delations to be accurate
+  // if ( targetRelFile in cssFiles && relFile !== cssFiles[targetRelFile] ) {
+  //     throw new TungstenError(
+  //         '${packageNameCapitalized} error - CSS file clash:'
+  //         + `${targetRelFile} from ${relFile} clashes with css file from ${cssFiles[targetRelFile]}`
+  //     )
+  // }
+  // process sass/scss/less
+  if (relFile.endsWith('.scss') || relFile.endsWith('.sass')) {
+    // get the sxss file content
+    const content = await fsPromises.readFile(filePathFull, 'utf8');
+    // save the dependencies that existed in last compile, if present
+    const oldDependencies = filePathFull in cssDependencies ? cssDependencies[filePathFull] : null;
+    const expiredDepencies = oldDependencies;
+    // get the new dependencies
+    const dependencies = relFile.endsWith('.scss') ? findScssDependencies(content, filePathFull) : findSassDependencies(content, filePathFull);
+    // save the dependencies of this file in { [key: string]: true } format
+    cssDependencies[filePathFull] = arrayToObjectTrue(dependencies);
+    // should we check for dep loop here?
+    // for each dependency
+    debug();
+    for (const dep of dependencies) {
+      // set this file as a depender (when that file updates, update this file)
+      debug(`setting depender ${filePathFull} depends on ${dep}`);
+      const dependers = cssDependers[dep] || {};
+      dependers[filePathFull] = true;
+      cssDependers[dep] = dependers;
+      // remove that dep from expired dependencies, leaving only former depencies
+      if (expiredDepencies !== null) delete expiredDepencies[dep];
+    }
+    debug();
+    //console.log('Ex Deps', oldDependencies)
+    // remove this file from dependers of files that are not dependencies anymore
+    for (const exDep in expiredDepencies) {
+      delete cssDependers[exDep][filePathFull];
+    }
+    debug('cssDependers', cssDependers);
+    bumpDependers(cssDependers, filePathFull);
+    //console.log('cssDependencies', cssDependencies)
+    //console.log('cssdependers', cssdependers)
+    // compile the sxss
+    const cssOrError = relFile.endsWith('.scss') ? scssToCss(content, filePathFull, styleImportBase) : sassToCss(content, filePathFull, styleImportBase);
+    // write to the build folder
+    if (typeof cssOrError === 'string') {
+      await fsPromises.writeFile(target, cssOrError);
+      debug('wrote sxss file', filePathFull, target);
+      //bumpdependers()
+    } else {
+      await fsPromises.writeFile(target, '');
+      cliError(`Error compiling stylesheet ${filePathFull}: ${String(cssOrError)}`);
+    }
+  } else {
+    // write to the build folder
+    await fsPromises.copyFile(filePathFull, target);
+    debug('wrote copy css file', filePathFull, target);
+  }
+  cssFiles[targetRelFile] = relFile;
+}
+export function compileStyles(projectDir, config, styleImportBase, buildLocation) {
+  cliOut(`Compiling app stylesheets`);
+  // we need to create and maintain a dependency tree for correct updating
+  // we are going to save the dependencies of each file
+  const cssDependencies = {};
+  // and the reverse, the dependers for each file
+  // so that we can do fast lookups both ways
+  const cssdependers = {};
+  // A depends on B
+  // B depends on C
+  // C depends on D
+  // OR
+  // A depends on B, C, D
+  // B depends on C, D
+  // C depends on D
+  // OR
+  // A is needed by none
+  // B is needed by A
+  // C is needed by B
+  // D is needed by C
+  // OR
+  // A is needed by none
+  // B is needed by A
+  // C is needed by B,A
+  // D is needed by C,B,A
+  const cssFiles = {};
+  const sourceLocation = config.sourceDir ? join(projectDir, config.sourceDir) : join(projectDir, config.codeDir);
+  const staticLocation = join(buildLocation, staticFolder);
+  const watchGlob = sourceLocation + '/**/*.{css,scss,sass,less}';
+  const ignoreGlob = buildLocation + '/**/*';
+  debug('Styles watchGlob', watchGlob);
+  const watcher = chokidar.watch(watchGlob, {
+    ignored: ignoreGlob
+    //ignoreInitial: true
+  });
+  watcher.on('all', async (event, filename) => {
+    filename = slash(filename);
+    debug('[styles watch event]', '(' + event + ')', filename);
+    if (event === 'add') {
+      processAndCopyFile(sourceLocation, staticLocation, filename, styleImportBase, cssFiles, cssDependencies, cssdependers);
+    }
+    if (event === 'change') {
+      processAndCopyFile(sourceLocation, staticLocation, filename, styleImportBase, cssFiles, cssDependencies, cssdependers);
+    }
+    // delete
+    // remove from transformedFiles
+  });
+  return new Promise((resolve, reject) => {
+    watcher.on('ready', async () => {
+      resolve(watcher);
+    });
+  });
+}

package/dist/build/compileUserApp.d.ts

@@ -0,0 +1,5 @@
+import type { CompilationInfo } from './CompilationInfo.js';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { Mode } from '../Mode.js';
+export declare function compileUserApp(projectDir: string, appConfig: FrameworkConfigComplete, mode: Mode): Promise<CompilationInfo>;
+//# sourceMappingURL=compileUserApp.d.ts.map

package/dist/build/compileUserApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileUserApp.d.ts","sourceRoot":"","sources":["../../src/build/compileUserApp.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAUtC,wBAAsB,cAAc,CAChC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,uBAAuB,EAAE,IAAI,EAAE,IAAI,GACnE,OAAO,CAAC,eAAe,CAAC,CA8C1B"}

package/dist/build/compileUserApp.js

@@ -0,0 +1,42 @@
+import { join } from 'path';
+import { compileJavascript } from "./compileJavascript.js";
+import { compileStyles } from "./compileStyles.js";
+import { copyAssets } from "./copyAssets.js";
+import { copyPublicFiles } from "./copyPublicFiles.js";
+import { buildCodeSubPath, bundleFolder, devBuildOuterFolder, prodBuildFolder } from "../settings.js";
+import { combineComponentCss } from "./combineComponentCss.js";
+//import { compileEnv } from './compileEnv.js'
+export async function compileUserApp(projectDir, appConfig, mode) {
+  const codeLocation = join(projectDir, appConfig.codeDir);
+  const relSourceDir = appConfig.sourceDir !== undefined && appConfig.sourceDir !== '' ? appConfig.sourceDir : appConfig.codeDir;
+  const sourceLocation = join(projectDir, relSourceDir);
+  const styleImportBase = appConfig.styleImportBase !== undefined ? join(sourceLocation, appConfig.styleImportBase) : sourceLocation;
+  const buildLocation = mode === 'dev' ? join(projectDir, devBuildOuterFolder) : join(projectDir, prodBuildFolder);
+  const codeSubPath = buildCodeSubPath;
+  const buildCodeLocation = join(buildLocation, codeSubPath);
+  const compileJavascriptPromise = compileJavascript(projectDir, appConfig, codeLocation, sourceLocation, styleImportBase, buildLocation, buildCodeLocation, mode);
+  //const compileEnvPromise = compileEnv(projectDir, appConfig, codeLocation, buildLocation, mode)
+  const compileStylesPromise = compileStyles(projectDir, appConfig, styleImportBase, buildLocation);
+  const copyAssetsPromise = copyAssets(projectDir, appConfig, buildLocation);
+  const copyPublicFilesPromise = copyPublicFiles(projectDir, appConfig, buildLocation);
+  const {
+    importAliases
+  } = await compileJavascriptPromise;
+  //await compileEnvPromise
+  await compileStylesPromise;
+  await copyAssetsPromise;
+  await copyPublicFilesPromise;
+  if (mode === 'prod') await combineComponentCss(buildLocation);
+  const compilationInfo = {
+    type: 'success',
+    projectDir,
+    codeLocation: join(projectDir, appConfig.codeDir),
+    buildLocation,
+    codeSubPath,
+    buildCodeLocation,
+    location: buildLocation,
+    importAliases
+  };
+  if (mode === 'prod') compilationInfo.bundleLocation = join(projectDir, bundleFolder);
+  return compilationInfo;
+}

package/dist/build/copyAssets.d.ts

@@ -0,0 +1,3 @@
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+export declare function copyAssets(projectDir: string, config: FrameworkConfigComplete, buildLocation: string): Promise<unknown> | undefined;
+//# sourceMappingURL=copyAssets.d.ts.map

package/dist/build/copyAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyAssets.d.ts","sourceRoot":"","sources":["../../src/build/copyAssets.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAiBpE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,gCA+CpG"}

package/dist/build/copyAssets.js

@@ -0,0 +1,47 @@
+import slash from 'slash';
+import chokidar from 'chokidar';
+import { join, dirname } from 'path';
+import { promises as fsPromises } from 'fs';
+import { cliOut } from "../cliOutput.js";
+async function copyFile(assetsLocation, targetLocation, filePathFull, event) {
+  const relFile = filePathFull.slice(assetsLocation.length + 1);
+  const target = join(targetLocation, relFile);
+  //cliNote('copy asset', filePathFull, target)
+  // create the folder if needed
+  await fsPromises.mkdir(dirname(target), {
+    recursive: true
+  });
+  return fsPromises.copyFile(filePathFull, target);
+}
+export function copyAssets(projectDir, config, buildLocation) {
+  if (config.assetsDir !== undefined) {
+    cliOut(`Copying assets`);
+    const assetsLocation = join(projectDir, config.assetsDir);
+    const targetLocation = join(buildLocation, '.assets' /*, config.assetsDir*/);
+    //console.log('copy assets from', assetsLocation, 'to', targetLocation)
+    const watchGlob = assetsLocation + '/**/*';
+    //const ignoreGlob = buildLocation + '/**/*'
+    const watcher = chokidar.watch(watchGlob, {
+      //ignored: ignoreGlob,
+      //ignoreInitial: true
+    });
+    watcher.on('all', async (event, filename) => {
+      filename = slash(filename);
+      //console.log('[assets watch event]', '('+event+')', filename)
+      if (event === 'add') {
+        copyFile(assetsLocation, targetLocation, filename, event);
+      }
+      if (event === 'change') {
+        copyFile(assetsLocation, targetLocation, filename, event);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      watcher.on('ready', () => {
+        //console.log('chokidar assets watcher ready')
+        //cliOut(`Copying assets`)
+        //cliNote(`Watching for new assets`)
+        resolve(watcher);
+      });
+    });
+  }
+}

package/dist/build/copyPackageModulesToPackagesFolder.d.ts

@@ -0,0 +1,4 @@
+import type { Mode } from '../Mode.js';
+import { Module } from '../Module.js';
+export declare function copyPackageModulesToPackagesFolder(modules: Module[], mode: Mode): Promise<any[]>;
+//# sourceMappingURL=copyPackageModulesToPackagesFolder.d.ts.map

package/dist/build/copyPackageModulesToPackagesFolder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyPackageModulesToPackagesFolder.d.ts","sourceRoot":"","sources":["../../src/build/copyPackageModulesToPackagesFolder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAItC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAQrC,wBAAsB,kCAAkC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,kBAkBrF"}