buner 0.0.2 → 1.0.1

package/cli/helpers/git.ts

@@ -0,0 +1,77 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+function isInGitRepository(): boolean {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
+
+    return true;
+  } catch (_) {
+    /* empty */
+  }
+
+  return false;
+}
+
+function isInMercurialRepository(): boolean {
+  try {
+    execSync('hg --cwd . root', { stdio: 'ignore' });
+
+    return true;
+  } catch (_) {
+    /* empty */
+  }
+
+  return false;
+}
+
+function isDefaultBranchSet(): boolean {
+  try {
+    execSync('git config init.defaultBranch', { stdio: 'ignore' });
+
+    return true;
+  } catch (_) {
+    /* empty */
+  }
+
+  return false;
+}
+
+const tryGitInit = (root: string): boolean => {
+  let didInit = false;
+
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+    if (isInGitRepository() || isInMercurialRepository()) {
+      return false;
+    }
+
+    execSync('git init', { stdio: 'ignore' });
+    didInit = true;
+
+    if (!isDefaultBranchSet()) {
+      execSync('git checkout -b main', { stdio: 'ignore' });
+    }
+
+    execSync('git add -A', { stdio: 'ignore' });
+    execSync('git commit -m "Initial commit from Create App"', {
+      stdio: 'ignore',
+    });
+
+    return true;
+  } catch (e) {
+    if (didInit) {
+      try {
+        fs.rmSync(path.join(root, '.git'), { recursive: true, force: true });
+      } catch (_) {
+        /* empty */
+      }
+    }
+
+    return false;
+  }
+};
+
+export { tryGitInit };

package/cli/helpers/install.ts

@@ -0,0 +1,26 @@
+/* eslint-disable no-console */
+import { exec } from 'node:child_process';
+
+import chalk from 'chalk';
+
+const { red } = chalk;
+
+const install = async () => {
+  return new Promise((resolve, reject) => {
+    exec('npm install', (error, stdout) => {
+      if (error) {
+        reject(error);
+
+        console.log(`${red(error)}`);
+
+        return;
+      }
+
+      console.log(stdout);
+
+      resolve(stdout);
+    });
+  });
+};
+
+export { install };

package/cli/helpers/is-folder-empty.ts

@@ -0,0 +1,40 @@
+import fs from 'fs';
+
+const isFolderEmpty = (root: string): boolean => {
+  const validFiles = [
+    '.DS_Store',
+    '.git',
+    '.gitattributes',
+    '.gitignore',
+    '.gitlab-ci.yml',
+    '.hg',
+    '.hgcheck',
+    '.hgignore',
+    '.idea',
+    '.npmignore',
+    '.travis.yml',
+    'LICENSE',
+    'Thumbs.db',
+    'docs',
+    'mkdocs.yml',
+    'npm-debug.log',
+    'yarn-debug.log',
+    'yarn-error.log',
+    'yarnrc.yml',
+    '.yarn',
+  ];
+
+  const conflicts = fs
+    .readdirSync(root)
+    .filter((file) => !validFiles.includes(file))
+    // Support IntelliJ IDEA-based editors
+    .filter((file) => !/\.iml$/.test(file));
+
+  if (conflicts.length > 0) {
+    return false;
+  }
+
+  return true;
+};
+
+export { isFolderEmpty };

package/cli/helpers/is-writeable.ts

@@ -0,0 +1,14 @@
+import fs from 'fs';
+
+const isWriteable = async (directory: string): Promise<boolean> => {
+  try {
+    await fs.promises.access(directory, fs.constants.W_OK);
+
+    return true;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (err) {
+    return false;
+  }
+};
+
+export { isWriteable };

package/cli/helpers/make-dir.ts

@@ -0,0 +1,7 @@
+import fs from 'fs';
+
+const makeDir = (root: string, options = { recursive: true }): Promise<string | undefined> => {
+  return fs.promises.mkdir(root, options);
+};
+
+export { makeDir };

package/cli/helpers/validate-pkg.ts

@@ -0,0 +1,17 @@
+import validateProjectName from 'validate-npm-package-name';
+
+export function validateNpmName(name: string): {
+  valid: boolean;
+  problems?: string[];
+} {
+  const nameValidation = validateProjectName(name);
+
+  if (nameValidation.validForNewPackages && !name.startsWith('-')) {
+    return { valid: true };
+  }
+
+  return {
+    valid: false,
+    problems: [...(nameValidation.errors || []), ...(nameValidation.warnings || [])],
+  };
+}

package/cli/install-template.ts

@@ -0,0 +1,77 @@
+/* eslint-disable no-console */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+import chalk from 'chalk';
+
+import { copy } from './helpers/copy.js';
+import { install } from './helpers/install.js';
+import { formatFiles } from './helpers/format-files.js';
+
+export const filename = fileURLToPath(import.meta.url);
+export const dirname = path.dirname(filename);
+
+interface Props {
+  appName: string;
+  root: string;
+}
+
+const { cyan } = chalk;
+
+const installTemplate = async (model: Props) => {
+  const { appName, root } = model;
+
+  console.log('\nInitializing project');
+  const copySource = ['**'];
+
+  await copy(copySource, root, {
+    cwd: path.join(dirname, '..'),
+  });
+
+  await formatFiles(root);
+
+  const packageJson = JSON.parse(await fs.readFile('package.json', 'utf8'));
+
+  packageJson.name = appName;
+  packageJson.description = '';
+  packageJson.version = '0.1.0';
+
+  delete packageJson.bin;
+  packageJson.scripts &&
+    Object.keys(packageJson.scripts).map((scriptName: string) => {
+      if (scriptName.startsWith('cli')) {
+        delete packageJson.scripts[scriptName];
+      }
+    });
+
+  packageJson.dependencies &&
+    Object.keys(packageJson.dependencies).map((dependency) => {
+      if (!dependency.startsWith('react')) {
+        delete packageJson.dependencies[dependency];
+      }
+    });
+
+  const devDeps = Object.keys(packageJson.devDependencies).length;
+
+  if (!devDeps) delete packageJson.devDependencies;
+
+  await fs.writeFile(path.join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + os.EOL);
+
+  console.log('\nInstalling dependencies:');
+
+  for (const dependency in packageJson.dependencies) {
+    console.log(`- ${cyan(dependency)}`);
+  }
+
+  if (devDeps) {
+    console.log('\nInstalling devDependencies:');
+
+    for (const dependency in packageJson.devDependencies) console.log(`- ${cyan(dependency)}`);
+  }
+
+  await install();
+};
+
+export { installTemplate };

package/eslint.config.mjs

@@ -0,0 +1,187 @@
+import { defineConfig, globalIgnores } from 'eslint/config';
+import { fixupConfigRules, fixupPluginRules } from '@eslint/compat';
+import react from 'eslint-plugin-react';
+import unusedImports from 'eslint-plugin-unused-imports';
+import _import from 'eslint-plugin-import';
+import typescriptEslint from '@typescript-eslint/eslint-plugin';
+import jsxA11Y from 'eslint-plugin-jsx-a11y';
+import prettier from 'eslint-plugin-prettier';
+import nextPlugin from '@next/eslint-plugin-next';
+import globals from 'globals';
+import tsParser from '@typescript-eslint/parser';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import js from '@eslint/js';
+import { FlatCompat } from '@eslint/eslintrc';
+import reactRefresh from 'eslint-plugin-react-refresh';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default defineConfig([
+  globalIgnores([
+    '.now/*',
+    '**/*.css',
+    '**/.changeset',
+    '**/dist',
+    'esm/*',
+    'public/*',
+    'tests/*',
+    'scripts/*',
+    '**/*.config.js',
+    '**/.DS_Store',
+    '**/node_modules',
+    '**/coverage',
+    '**/.next',
+    '**/build',
+    '!**/.commitlintrc.cjs',
+    '!**/.lintstagedrc.cjs',
+    '!**/jest.config.js',
+    '!**/plopfile.js',
+    '!**/react-shim.js',
+    '!**/tsup.config.ts',
+  ]),
+  ...fixupConfigRules(
+    compat.extends('plugin:react/recommended', 'plugin:prettier/recommended', 'plugin:react-hooks/recommended', 'plugin:jsx-a11y/recommended')
+  ),
+  {
+    settings: {
+      react: {
+        version: 'detect',
+      },
+    },
+  },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+
+    plugins: {
+      react: fixupPluginRules(react),
+      'unused-imports': unusedImports,
+      import: fixupPluginRules(_import),
+      '@typescript-eslint': typescriptEslint,
+      'react-refresh': reactRefresh,
+      'jsx-a11y': fixupPluginRules(jsxA11Y),
+      prettier: fixupPluginRules(prettier),
+      '@next/next': fixupPluginRules(nextPlugin),
+    },
+
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+
+      parser: tsParser,
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+    },
+
+    rules: {
+      'no-console': 'warn',
+      'react/prop-types': 'off',
+      'react/jsx-uses-react': 'off',
+      'react/react-in-jsx-scope': 'off',
+      'react-hooks/exhaustive-deps': 'off',
+      'jsx-a11y/click-events-have-key-events': 'warn',
+      'jsx-a11y/interactive-supports-focus': 'warn',
+      'prettier/prettier': 'warn',
+      'no-unused-vars': 'off',
+      'unused-imports/no-unused-vars': 'off',
+      'unused-imports/no-unused-imports': 'warn',
+      'react-refresh/only-export-components': 'error',
+      'no-new': 'error',
+      complexity: ['error', 15],
+      'max-depth': ['error', 4],
+
+      '@typescript-eslint/no-unused-vars': [
+        'warn',
+        {
+          args: 'after-used',
+          ignoreRestSiblings: false,
+          argsIgnorePattern: '^_.*?$',
+        },
+      ],
+
+      'import/order': [
+        'warn',
+        {
+          groups: ['type', 'builtin', 'object', 'external', 'internal', 'parent', 'sibling', 'index'],
+
+          pathGroups: [
+            {
+              pattern: '~/**',
+              group: 'external',
+              position: 'after',
+            },
+            {
+              pattern: '@/**',
+              group: 'internal',
+              position: 'after',
+            },
+          ],
+
+          'newlines-between': 'always',
+        },
+      ],
+
+      'react/self-closing-comp': 'warn',
+
+      'react/jsx-sort-props': [
+        'warn',
+        {
+          callbacksLast: true,
+          shorthandFirst: true,
+          noSortAlphabetically: false,
+          reservedFirst: true,
+        },
+      ],
+
+      'padding-line-between-statements': [
+        'warn',
+        {
+          blankLine: 'always',
+          prev: '*',
+          next: 'return',
+        },
+        {
+          blankLine: 'always',
+          prev: ['const', 'let', 'var'],
+          next: '*',
+        },
+        {
+          blankLine: 'any',
+          prev: ['const', 'let', 'var'],
+          next: ['const', 'let', 'var'],
+        },
+      ],
+
+      quotes: [
+        'warn',
+        'single',
+        {
+          avoidEscape: true,
+        },
+      ],
+    },
+  },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    plugins: {
+      '@next/next': fixupPluginRules(nextPlugin),
+    },
+    rules: {
+      '@next/next/no-img-element': 'off',
+    },
+  },
+]);

package/index.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta charset="utf-8" />
+    <link rel="icon" href="#__BASE_URL__/favicon.ico" sizes="any" />
+    <link rel="icon" href="#__BASE_URL__/favicon.svg" type="image/svg+xml" />
+    <link rel="manifest" href="#__BASE_URL__/manifest.webmanifest" />
+    <meta name="locale" content="en-US" />
+    <meta name="ROBOTS" content="NONE, NOARCHIVE" />
+    <meta name="GOOGLEBOT" content="NOARCHIVE" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=2.0, user-scalable=yes" />
+    <meta name="description" content="This is the description for Precise Alloy page." />
+    <title>B2C Home</title>
+    <meta name="twitter:image" content="#__BASE_URL__/icons/apple-touch-icon.png" />
+    <meta name="og:image" content="#__BASE_URL__/icons/apple-touch-icon.png" />
+    <meta name="theme-color" content="#fff" media="(prefers-color-scheme: light)" />
+    <meta name="theme-color" content="#fff" media="(prefers-color-scheme: dark)" />
+    <link rel="apple-touch-icon" sizes="180x180" href="#__BASE_URL__/icons/apple-touch-icon.png" />
+    <link rel="icon" type="image/png" sizes="32x32" href="#__BASE_URL__/icons/favicon-32x32.png" />
+    <link rel="icon" type="image/png" sizes="16x16" href="#__BASE_URL__/icons/favicon-16x16.png" />
+    <link rel="manifest" href="#__BASE_URL__/manifest.json" crossorigin />
+    <link rel="stylesheet" href="#__BASE_URL__/assets/css/style-base.css" as="style" />
+    <link rel="stylesheet" href="#__BASE_URL__/assets/css/pl-states.css" as="style" />
+    <link rel="preload" href="#__BASE_URL__/assets/fonts/work-sans/WorkSans.woff2" as="font" type="font/woff2" />
+    <link rel="preload" href="#__BASE_URL__/assets/fonts/crimson-text/CrimsonText.woff2" as="font" type="font/woff2" />
+
+    <script defer src="#__BASE_URL__/assets/js/color-mode.js"></script>
+    <script src="#__BASE_URL__/assets/js/theme-critical.js"></script>
+
+    <script defer src="#__BASE_URL__/assets/js/main.js"></script>
+
+    <!-- Don't include this line in a production site -->
+    <script type="module" src="#__BASE_URL__/assets/js/mock-api.js"></script>
+    <!-- Don't include this line in a production site -->
+  </head>
+
+  <body>
+    <!--app-html-->
+    <script type="module" src="/xpack/react-loader-init.tsx"></script>
+    <script type="module" defer src="#__BASE_URL__/assets/js/pl-states.js"></script>
+  </body>
+</html>

package/integration.ts

@@ -0,0 +1,179 @@
+/* eslint-disable no-console */
+import fs from 'fs';
+import path, { resolve } from 'path';
+import crypto from 'node:crypto';
+import nodeFs from 'node:fs';
+
+import slash from 'slash';
+import { glob } from 'glob';
+import { loadEnv } from 'vite';
+import chalk from 'chalk';
+
+interface CopyItem {
+  from: string;
+  to?: string;
+}
+
+interface FileExistCheck {
+  folder?: string;
+  fileName: string | RegExp;
+}
+
+const argvModeIndex = process.argv.indexOf('--mode');
+const mode =
+  argvModeIndex >= 0 && argvModeIndex < process.argv.length - 1 && !process.argv[argvModeIndex + 1].startsWith('-')
+    ? process.argv[argvModeIndex + 1]
+    : 'production';
+const projectRoot = process.cwd();
+const xpackEnv = loadEnv(mode, projectRoot);
+const toAbsolute = (p: string) => slash(path.resolve(projectRoot, p));
+const log = console.log.bind(console);
+
+const hashes: Map<string, string> = new Map();
+const staticBasePath = toAbsolute('dist/static');
+const srcBasePath = toAbsolute('dist/static/assets');
+const destBasePath = toAbsolute(xpackEnv.VITE_INTE_ASSET_DIR);
+const patternPath = xpackEnv.VITE_INTE_PATTERN_DIR ? toAbsolute(xpackEnv.VITE_INTE_PATTERN_DIR) : undefined;
+
+if (patternPath && fs.existsSync(patternPath)) {
+  fs.rmSync(patternPath, { recursive: true, force: true });
+
+  fs.mkdirSync(patternPath, { recursive: true });
+}
+
+const copyItems: CopyItem[] = [
+  { from: 'css' },
+  { from: 'fonts' },
+  { from: 'images' },
+  { from: 'js' },
+  { from: 'vendors' },
+  { from: 'hashes.json' },
+  { from: 'pages', to: patternPath },
+];
+const hashItems: string[] = ['css', 'images', 'js'];
+
+copyItems.forEach((item) => {
+  const srcPath = slash(path.join(srcBasePath, item.from));
+  const destPath = slash(item.to ?? path.join(destBasePath, item.from));
+
+  if (!fs.existsSync(srcPath)) {
+    return;
+  }
+
+  log(`Copy file ${srcPath} to ${destPath}`);
+
+  if (fs.statSync(srcPath).isDirectory()) {
+    if (fs.existsSync(destPath)) {
+      fs.rmSync(destPath, { recursive: true, force: true });
+    }
+
+    fs.mkdirSync(destPath, { recursive: true });
+
+    fs.cpSync(srcPath, destPath, { recursive: true, force: true });
+  } else {
+    const destDirPath = path.dirname(destPath);
+
+    if (!fs.existsSync(destDirPath)) {
+      fs.mkdirSync(destDirPath);
+    }
+
+    fs.copyFileSync(srcPath, destPath);
+  }
+});
+
+hashItems.forEach((item) => {
+  const srcPath = slash(path.join(srcBasePath, item));
+  const files = glob.sync(srcPath + '/**/*.{css,js,svg}');
+
+  files.forEach((file) => {
+    const relativePath = slash(file.substring(staticBasePath.length));
+
+    if (!/\.0x[a-z0-9_-]{8,12}\.\w+$/gi.test(file)) {
+      const content = fs.readFileSync(file);
+      const sha1Hash = crypto.createHash('sha1');
+
+      sha1Hash.update(content);
+      const hash = sha1Hash.digest('base64url').substring(0, 10);
+
+      hashes.set(relativePath, hash);
+    } else {
+      hashes.set(relativePath, '');
+    }
+  });
+});
+
+const sortedHashes = Array.from(hashes)
+  .sort((a, b) => a[0].localeCompare(b[0]))
+  .reduce(
+    (obj, [key, value]) => {
+      obj[key] = value;
+
+      return obj;
+    },
+    {} as { [key: string]: string }
+  );
+
+fs.writeFileSync(path.join(destBasePath, 'hashes.json'), JSON.stringify(sortedHashes, null, '  '));
+
+if (patternPath) {
+  fs.mkdirSync(patternPath, { recursive: true });
+  glob.sync('./dist/static/{atoms,molecules,organisms,templates,pages}/**/*.*').forEach((p) => {
+    let basename = '';
+    const segments = slash(p).split('/');
+
+    if (segments.length < 4) return;
+    switch (segments.length) {
+      case 4:
+        basename = path.basename(slash(p).replaceAll(/(atoms|molecules|organisms|templates|pages)\/([\w._-]+)$/gi, '$1-$2'));
+        fs.copyFileSync(p, resolve(patternPath, basename));
+        break;
+      default:
+        segments.splice(0, 2);
+        nodeFs.cpSync(p, resolve(patternPath, segments.join('-')), { recursive: true });
+        break;
+    }
+  });
+
+  glob.sync(slash(path.resolve(patternPath + '/**/*.{htm,html}'))).forEach((p) => {
+    const text = fs.readFileSync(p, 'utf-8');
+    const newText = text
+      .replaceAll(/react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, 'react-loader.0x00000000.js')
+      .replaceAll(/\.svg\?v=[a-z0-9_-]+/gi, '.svg');
+
+    if (text !== newText) {
+      fs.writeFileSync(p, newText);
+    }
+  });
+}
+
+const checkExistFileList: FileExistCheck[] = [
+  { fileName: 'hashes.json' },
+  { fileName: /react-loader\.0x[a-z0-9_-]{8,12}\.js/gi, folder: 'js' },
+  { fileName: 'main.js', folder: 'js' },
+];
+let isAllExist = true;
+
+checkExistFileList.forEach((file) => {
+  if (typeof file.fileName === 'string') {
+    const destPath = slash(path.join(destBasePath, file.folder ?? '', file.fileName.toString()));
+
+    if (!fs.existsSync(destPath)) {
+      log(chalk.yellow(`Cannot find: ${destPath}`));
+      isAllExist = false;
+    }
+  } else {
+    const fileName = file.fileName;
+    const folderFiles = slash(path.join(destBasePath, file.folder ?? ''));
+    const files = fs.readdirSync(folderFiles);
+    const found = files.find((f) => fileName.test(f));
+
+    if (!found) {
+      log(chalk.yellow(`Cannot find: ${slash(path.join(folderFiles, fileName.toString()))}`));
+      isAllExist = false;
+    }
+  }
+});
+
+if (!isAllExist) {
+  process.exit(1);
+}