sugar-scripts 0.2.0-beta.0

package/src/core/init-running-context.ts

@@ -0,0 +1,27 @@
+import {
+  findProject,
+  findPackage
+} from '../shared/file-helpers';
+
+import {
+  SugarScriptsContext
+} from './running-context';
+
+export const initRunningContext = async (dir: string) => {
+  const {
+    root,
+    packageJson,
+    packageConfig
+  } = await findPackage(dir);
+  const { projectRoot, projectConfig } = await findProject(root);
+  if (!packageConfig || !projectConfig) {
+    throw new Error('')
+  }
+  return new SugarScriptsContext({
+    root,
+    packageName: packageJson.name,
+    packageConfig,
+    projectRoot,
+    projectConfig
+  })
+}

package/src/core/run-application.ts

@@ -0,0 +1,12 @@
+import {
+  Application
+} from 'sugar-server';
+
+export const runApplication = (
+  ApplicationClass: typeof Application,
+  port: number
+) => {
+  const app = new ApplicationClass();
+
+  app.listen(port)
+}

package/src/core/running-context.ts

@@ -0,0 +1,92 @@
+import { createHash } from 'crypto';
+import path from 'path';
+
+type BuildEntry = { [key: string]: string|string[] };
+
+interface PackageConfig {
+  browser?: {
+    /**
+     * 是否构建dll用的输出
+     */
+    dll?: boolean;
+    /**
+     * 输出目录
+     */
+    output: string;
+    /**
+     * controller/index
+     */
+    input?: string;
+    entry?: BuildEntry
+  };
+
+  server?: {
+    dll?: boolean;
+    output: string;
+    entry: string;
+    render?: string;
+  };
+}
+
+interface ProjectConfig {
+  cacheDir: string;
+}
+
+export function getHashFromRoot (
+  root: string
+) {
+  const hash = createHash('md5');
+  hash.update(root);
+  return `s_${hash.digest('hex')}`;
+}
+
+export class SugarScriptsContext {
+  root: string;
+  rootHash: string;
+  packageName: string;
+  packageConfig: PackageConfig;
+  projectRoot: string;
+  projectConfig: ProjectConfig;
+
+  constructor (
+    {
+      root,
+      packageName,
+      packageConfig,
+      projectRoot,
+      projectConfig
+    }: {
+      root: string;
+      packageName: string;
+      packageConfig: PackageConfig;
+      projectRoot: string;
+      projectConfig: ProjectConfig;
+    }
+  ) {
+    this.root = root;
+    this.packageName = packageName;
+    this.packageConfig = packageConfig;
+    this.projectRoot = projectRoot;
+    this.projectConfig = projectConfig;
+    this.rootHash = getHashFromRoot(root);
+  }
+
+  serverEntryName = 'main';
+
+  getStartFilePath () {
+    if (this.packageConfig.server) {
+      return path.resolve(
+        this.root,
+        this.packageConfig.server.output,
+        this.serverEntryName
+      )
+    }
+  }
+
+  getCacheDir () {
+    return path.resolve(
+      this.projectRoot,
+      this.projectConfig.cacheDir
+    )
+  }
+}

package/src/custom-config.type.ts

@@ -0,0 +1,66 @@
+import type {
+  ControllerContext
+} from 'sugar-server';
+import type WebpackChainConfig from 'webpack-chain';
+
+import {
+  SugarScriptsContext
+} from './core/running-context'
+
+export namespace SugarScriptsProject {
+  export type BrowserWebpackConfig = CustomWebpackConfig;
+
+  export type ServerWebpackConfig = CustomWebpackConfig;
+
+  export interface PackageConfig {
+    browser?: {
+      /**
+       * 是否构建dll用的输出
+       */
+      dll?: boolean;
+      /**
+       * 输出目录
+       */
+      output: string;
+      /**
+       * controller/index
+       */
+      input?: string;
+      entry?: BuildEntry
+    };
+
+    server?: {
+      dll?: boolean;
+      output: string;
+      entry: string;
+      render?: string;
+    };
+  }
+
+  export interface ProjectConfig {
+    cacheDir: string;
+  }
+
+
+  export interface CustomRender<C = any> {
+    (
+      ctx: ControllerContext,
+      entries: string[] | {[key: string]: string[]},
+      custom: C
+    ): string
+  };
+}
+
+type BuildEntry = { [key: string]: string|string[] };
+
+export type CustomWebpackConfig = (
+  webpackChainConfig: WebpackChainConfig,
+  context: SugarScriptsContext
+) => void;
+
+export type CustomRender<C = any> = (
+  ctx: ControllerContext,
+  entries: string[] | {[key: string]: string[]},
+  custom: C
+) => string;
+

package/src/index.ts

@@ -0,0 +1,7 @@
+export * as entry from './core/entry';
+export * as appUtils from './app-utils'
+
+export {
+  SugarScriptsProject
+} from './custom-config.type';
+

package/src/shared/file-helpers.ts

@@ -0,0 +1,192 @@
+import fs from 'fs';
+import path from 'path';
+
+import {
+  SUGAR_PACKAGE_CONFIG_FILENAME,
+  SUGAR_PROJECT_CONFIG_FILENAME
+} from '../constants';
+import {
+  SugarScriptsProject
+} from '../custom-config.type';
+// nodejs v10 支持
+// nodejs v14 才开始支持require('fs/promises')
+const fsPromises = fs.promises;
+
+export const searchFiles = async (
+  dir: string,
+  fileCheck: string | ((filePath: string) => boolean),
+  exclude?: string
+) => {
+  try {
+    await fsPromises.access(dir)
+  } catch (e) {
+    return [];
+  }
+  const files = await fsPromises.readdir(dir);
+  let currentFiles: string[] = [];
+
+  await Promise.all(
+    files.map(async (filename) => {
+      if (exclude === filename) return;
+      const fileOrDir = path.join(dir, filename);
+      const stats = await fsPromises.stat(fileOrDir);
+      if (stats.isFile()) {
+        if (typeof fileCheck === 'string') {
+          if (filename === fileCheck) {
+            currentFiles.push(fileOrDir)
+          }
+        } else if (fileCheck(fileOrDir)) {
+          currentFiles.push(fileOrDir)
+        }
+      } else if (stats.isDirectory()) {
+        const childCurrentFiles = await searchFiles(fileOrDir, fileCheck);
+        currentFiles = currentFiles.concat(childCurrentFiles);
+      }
+    })
+  )
+  return currentFiles;
+}
+
+export const findSiblingFile = async (
+  currentFilePath: string,
+  searchFileName: string
+) => {
+  const dir = path.dirname(currentFilePath);
+  const searchFilePath = path.join(dir, searchFileName);
+
+  const searchFileStat = await fsPromises.stat(searchFilePath);
+  if (searchFileStat.isFile()) {
+    return searchFilePath;
+  }
+
+  return null;
+}
+
+export const findParentFile = async (
+  currentFilePath: string,
+  searchFileName: string
+) => {
+  const dir = path.resolve(
+    path.dirname(currentFilePath),
+    '../'
+  );
+  const searchFilePath = path.join(dir, searchFileName);
+
+  const searchFileStat = await fsPromises.stat(searchFilePath);
+  if (searchFileStat.isFile()) {
+    return searchFilePath;
+  }
+
+  return null;
+}
+
+export const loadJSON = async (filePath: string) => {
+  try {
+    const contentBuffer = await fsPromises.readFile(filePath);
+    const content = contentBuffer.toString();
+
+    return JSON.parse(content);
+  } catch (e) {
+    return {};
+  }
+}
+
+export const writeFileSync = (
+  filePath: string,
+  data: string | NodeJS.ArrayBufferView
+) => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(
+    filePath,
+    data
+  )
+}
+
+export const findPackage = async (dir: string): Promise<{
+  root: string;
+  packageJson: any;
+  packageConfig: SugarScriptsProject.PackageConfig | null;
+}> => {
+  const packagePath = path.resolve(dir, 'package.json');
+
+  let existed = true;
+  try {
+    await fsPromises.access(packagePath, fs.constants.F_OK);
+  } catch (e) {
+    existed = false;
+  }
+
+  let packageConfig = null;
+  try {
+    packageConfig = require(
+      path.resolve(dir, SUGAR_PACKAGE_CONFIG_FILENAME)
+    ).packageConfig;
+  } catch (e) {}
+
+  if (existed) {
+    return {
+      root: dir,
+      packageJson: require(
+        packagePath
+      ),
+      packageConfig
+    };
+  }
+
+  if (dir === '/') {
+    throw new Error('not found package.json');
+  }
+
+  return findPackage(
+    path.resolve(dir, '../')
+  )
+}
+
+export const findProject = async (dir: string): Promise<{
+  projectRoot: string,
+  projectConfig: SugarScriptsProject.ProjectConfig
+}> => {
+  const projectPath = path.resolve(dir, SUGAR_PROJECT_CONFIG_FILENAME);
+
+  let projectConfig = null;
+  try {
+    projectConfig = require(projectPath).projectConfig;
+  } catch (e) {}
+
+  if (dir === '/') {
+    throw new Error('not found sugar.project');
+  }
+
+  if (projectConfig) {
+    return {
+      projectRoot: dir,
+      projectConfig
+    };
+  }
+
+  return findProject(
+    path.resolve(dir, '../')
+  )
+}
+
+export const rm = async (filePath: string) => {
+  const stat = await fsPromises.stat(filePath);
+  if (
+    stat.isFile()
+    || stat.isSymbolicLink()
+  ) {
+    await fsPromises.unlink(filePath);
+    return;
+  }
+  if (stat.isDirectory()) {
+    const childFilePaths = await fsPromises.readdir(filePath);
+    await Promise.all(
+      childFilePaths.map((childFilePath) => (
+        rm(path.resolve(filePath, childFilePath))
+      ))
+    );
+    await fsPromises.rmdir(filePath);
+    return;
+  }
+}

package/src/typings.d.ts

@@ -0,0 +1,8 @@
+declare module 'babel-loader' {}
+
+declare module 'webpack-manifest-plugin' {
+  export class WebpackManifestPlugin {
+    constructor (options: any);
+    apply: any
+  }
+}

package/src/webpack/auto-entries.ts

@@ -0,0 +1,5 @@
+var a = require(process.env.SUGAR_PROJECT_REAL_ENTRY || '');
+
+a.default.ENTRIES = process.env.SUGAR_PROJECT_ENTRIES;
+
+export default a.default;

package/src/webpack/dll-dependencies-manifest-plugin.ts

@@ -0,0 +1,115 @@
+import webpack from 'webpack';
+
+import {
+  writeFileSync
+} from '../shared/file-helpers';
+
+export interface DllDependenciesManifestPluginOptions {
+  dllAssets: {
+    [dllName: string]: string[];
+  }
+  fileName: string,
+  generate: (entries: {
+    [entry: string]: string[]
+  }) => any
+}
+
+const PLUGIN_NAME = 'DllDependenciesManifestPlugin';
+
+export class DllDependenciesManifestPlugin {
+  options: DllDependenciesManifestPluginOptions;
+  constructor (options: DllDependenciesManifestPluginOptions) {
+    this.options = options;
+  }
+
+  apply (compiler: webpack.Compiler) {
+    const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+
+    compiler.hooks.done.tap(
+      PLUGIN_NAME,
+      (stats) => {
+        var data = stats.toJson({
+          all: false,
+          entrypoints: true,
+          chunks: true,
+          chunkModules: true,
+          // nestedModules: true,
+          dependentModules: true,
+          moduleAssets: true,
+          assets: true,
+          modules: true,
+          // moduleTrace: true,
+          // reasons: true,
+          chunkRelations: true,
+          ids: true,
+          publicPath: true
+        })
+
+        const publicPath = data.publicPath;
+        const entries: {
+          [entry: string]: string[]
+        } = data.entrypoints
+          ? Object.keys(data.entrypoints).reduce((entries, entryKey) => {
+            entries[entryKey] = [];
+            const entryAssets = data.entrypoints![entryKey].assets;
+            if (entryAssets) {
+              const normalizePath = (path: string): string => {
+                if (!path.endsWith('/')) {
+                  return `${path}/`;
+                }
+
+                return path;
+              };
+
+              entries[entryKey] = entries[entryKey].concat(
+                entryAssets.map(({ name }) => (
+                  publicPath ? normalizePath(publicPath) + name : name
+                ))
+              )
+            };
+            return entries;
+          }, {} as {
+            [entry: string]: string[]
+          })
+          : {};
+
+        data.chunks?.forEach((chunk) => {
+          if (chunk.entry) {
+            let depDllAssets: string[] = [];
+            chunk.modules?.forEach((module) => {
+              if (
+                module.type !== 'module'
+                || !module.identifier
+              ) {
+                return;
+              }
+              const dllNameResult = /dll-reference (.+)$/.exec(module.identifier)
+              if (!dllNameResult) {
+                return;
+              }
+              const dllName = dllNameResult[1];
+              depDllAssets = depDllAssets.concat(
+                this.options.dllAssets[dllName]
+              )
+            })
+            if (entries[chunk.id as any]) {
+              entries[chunk.id as any] = depDllAssets.concat(entries[chunk.id as any])
+            }
+          }
+        })
+
+        // 去重复
+        Object.keys(entries).forEach((key) => {
+          entries[key] = Array.from(new Set(entries[key]))
+        })
+
+        const manifest = this.options.generate(entries);
+
+        writeFileSync(
+          this.options.fileName,
+          JSON.stringify(manifest, null, 2)
+        )
+      }
+    )
+  }
+}

package/src/webpack/load-manifest.ts

@@ -0,0 +1,73 @@
+import path from 'path';
+
+import {
+  searchFiles,
+  findParentFile,
+  loadJSON
+} from '../shared/file-helpers';
+
+export async function loadAllDllModulesManifest (
+  dir: string,
+  exclude?: string
+): Promise<{
+  context: string;
+  manifest: {
+    name: string;
+    content: any;
+  };
+  moduleName: string;
+  name: string;
+  assets: string[]
+}[]> {
+  const moduleFilePaths = await searchFiles(
+    dir,
+    'dll.modules.manifest.json',
+    exclude
+  );
+
+  const modules = await Promise.all(
+    moduleFilePaths.map(async (moduleFilePath) => {
+      const moduleConfigFilePath = await findParentFile(
+        moduleFilePath,
+        'manifest.json'
+      );
+      if (!moduleConfigFilePath) {
+        throw new Error(`not find manifest.json for ${moduleFilePath}`)
+      }
+      const moduleConfig = await loadJSON(moduleConfigFilePath);
+      const module = await loadJSON(moduleFilePath);
+      const name = module.name.split('_sn_').slice(1).join('_sn_');
+      return {
+        context: moduleConfig.context,
+        manifest: module,
+        moduleName: module.name,
+        name,
+        assets: moduleConfig.entries[name]
+      }
+    })
+  )
+
+  return modules.filter((module) => !!module) as {
+    context: string;
+    manifest: {
+      name: string;
+      content: any;
+    };
+    moduleName: string;
+    name: string;
+    assets: string[]
+  }[];
+}
+
+export async function loadBaseManifest (
+  dir: string,
+  rootHash: string
+) {
+  return loadJSON(
+    path.resolve(
+      dir,
+      rootHash,
+      './manifest.json'
+    )
+  );
+}

package/src/webpack/run-webpack.ts

@@ -0,0 +1,22 @@
+import webpack from 'webpack';
+import WebpackChainConfig from 'webpack-chain';
+
+
+export const runWebpack = (
+  chainConfig: WebpackChainConfig
+) => {
+  const compiler = webpack(
+    chainConfig.toConfig()
+  );
+
+  return new Promise((resolve, reject) => {
+    compiler.run((err, stats) => {
+      if (err || stats && stats.hasErrors()) {
+        reject(err || stats?.toString())
+        return;
+      }
+      console.log(stats?.toString())
+      resolve(stats)
+    })
+  })
+}