@genesislcap/build-kit 14.162.4 → 14.162.5

package/src/utils/child-process.ts

@@ -1,115 +0,0 @@
-import { spawnSync, spawn } from 'node:child_process';
-import { resolve as resolvePath, relative } from 'node:path';
-import consola from 'consola';
-
-export interface RunOptions {
-  exitOnError?: boolean;
-  prefixCommandWithNode?: boolean;
-  verbose?: boolean;
-  env?: Record<string, string>;
-  nodeArgs?: string;
-}
-
-export const run = (cwd, command, options: RunOptions = {}) => {
-  const {
-    exitOnError = true,
-    // defaulting to true for Windows support
-    prefixCommandWithNode = true,
-    env = { ...process.env },
-    nodeArgs = '',
-    verbose = true,
-  } = options;
-
-  const fullCommand = prefixCommandWithNode ? `node ${nodeArgs} ${command}` : command;
-
-  const result = spawnSync(fullCommand, {
-    shell: true,
-    cwd,
-    stdio: verbose ? 'inherit' : 'ignore',
-    env,
-  });
-
-  if (result.status === 1 && exitOnError) {
-    process.exit(result.status);
-  }
-
-  return result;
-};
-
-const normaliseNPMCLI = (cli: string): string => {
-  if (cli.toLowerCase() === 'npm') {
-    return process.platform.match(/^win/) ? 'npm.cmd' : 'npm';
-  }
-  return cli;
-};
-
-export const runAsync = async (cwd, command, options: RunOptions = {}): Promise<Error | null> => {
-  const {
-    exitOnError = true,
-    prefixCommandWithNode = true,
-    env = { ...process.env },
-    nodeArgs = '',
-    verbose = true,
-  } = options;
-
-  return new Promise((resolve, reject) => {
-    const chunks = command.trim().split(' ');
-    const fullCommand = prefixCommandWithNode
-      ? `node ${nodeArgs} ${chunks.shift()}`
-      : chunks.shift();
-    const crossPlatformCommand = normaliseNPMCLI(fullCommand);
-    const child = spawn(crossPlatformCommand, chunks, {
-      cwd,
-      stdio: verbose ? 'inherit' : 'ignore',
-      env,
-    });
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(null);
-      } else {
-        const err = new Error(`Unexpected error executing ${command}`);
-        if (exitOnError) {
-          consola.error(err);
-          return process.exit(code);
-        }
-        reject(err);
-      }
-    });
-    child.on('error', (err) => {
-      if (exitOnError) {
-        consola.error(err);
-        return process.exit(1);
-      }
-      reject(err);
-    });
-  });
-};
-
-// Based on https://github.com/unjs/giget/blob/main/src/_utils.ts#L110
-
-const currentShell = () => {
-  if (process.env.SHELL) {
-    return process.env.SHELL;
-  }
-  if (process.platform === 'win32') {
-    return 'cmd.exe';
-  }
-  return '/bin/bash';
-};
-
-export const startShell = (cwd: string) => {
-  cwd = resolvePath(cwd);
-  const shell = currentShell();
-  consola.info(`(experimental) Opening shell in ${relative(process.cwd(), cwd)}...`);
-  // spawnSync command is quoted to support paths with spaces on Windows (C:/Program Files etc.)
-  spawnSync(`"${shell}"`, [], {
-    cwd,
-    shell: true,
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      // DEBUG (set via log-level) messes up zsh
-      DEBUG: undefined,
-    },
-  });
-};

package/src/utils/config.ts

@@ -1,45 +0,0 @@
-import defu from 'defu';
-import type { PackageJson } from 'pkg-types';
-import { resolveFederationConfig, getFederatedPkgName } from './federation';
-import { tryRequire } from './npm';
-
-const getDefaultConfig = (packageName) => ({
-  app: {},
-  builder: {
-    default: 'webpack',
-    dev: 'vite',
-    lint: 'eslint-stylelint',
-    test: 'uvu-playwright',
-  },
-  clean: !process.env.GENX_NO_CLEAN,
-  copyAssets: ['**/*.{css,jpg,png,svg,mp4,ogg,webm}'],
-  env: [
-    'API_HOST',
-    'DEFAULT_ORGANISATION',
-    'DEFAULT_USER',
-    'DEFAULT_PASSWORD',
-    'ENABLE_SSO',
-    'GENX.*',
-    'GENX_*',
-    'FORCE_HTTP',
-    'SOCKET_EXT',
-  ],
-  federation: {
-    name: getFederatedPkgName(packageName),
-  },
-});
-
-const readConfig = (packageJSON: PackageJson, path = './genx.config') => {
-  const genxConfig = tryRequire(path) || {};
-  const packageJSONConfig = packageJSON.genx || {};
-  const defaultConfig = getDefaultConfig(packageJSON.name);
-  return defu(genxConfig, packageJSONConfig, defaultConfig);
-};
-
-export const loadConfig = async (packageJSON: PackageJson) => {
-  const config = readConfig(packageJSON);
-  return {
-    ...config,
-    federation: await resolveFederationConfig(config.federation, packageJSON),
-  };
-};

package/src/utils/console.ts

@@ -1 +0,0 @@
-export { bold, dim, green, blue, white, yellow, grey, italic } from 'chalk';

package/src/utils/env.ts

@@ -1,71 +0,0 @@
-import consola from 'consola';
-import type { BuildContext, ENV } from '../types';
-
-export const setNodeEnv = (targetEnv: ENV) => {
-  const currentEnv = process.env.NODE_ENV;
-  if (currentEnv && currentEnv !== targetEnv) {
-    consola.warn(`Changing \`NODE_ENV\` from \`${currentEnv}\` to \`${targetEnv}\`.`);
-  }
-
-  process.env.NODE_ENV = targetEnv;
-};
-
-const resolveEnvValue = (ctx: BuildContext, key: string, value: string) => {
-  // `-e `FOO` case
-  // 1. check package.json config
-  // 2. fall back to a truthy value (shortcut for setting env var flags where exact value isn't important as long as it's truthy e.g. -e CI)
-  // we don't check process.env because there it'd mean setting env variable to the same value it already has
-  if (!value) {
-    return ctx.pkg.config && ctx.pkg.config[key] !== undefined ? ctx.pkg.config[key] : '1';
-  }
-
-  // `-e FOO=ABC` case
-  // 1. check package.json config
-  if (ctx.pkg.config && ctx.pkg.config[value] !== undefined) {
-    return ctx.pkg.config[value];
-  }
-
-  // 2. check process.env
-  if (process.env[value] !== undefined) {
-    return process.env[value];
-  }
-
-  // 3. fall back to provided value
-  return value;
-};
-
-export const setEnvVars = (ctx: BuildContext) => {
-  const { env = '' } = ctx.cli.options;
-  const envCombined = Array.isArray(env) ? env.join(',') : env;
-  const vars = envCombined.split(',');
-  vars.forEach((v) => {
-    const [keyRaw, valueRaw] = v.split('=');
-    const key = (keyRaw || '').trim();
-    const value = (valueRaw || '').trim();
-    if (key) {
-      const resolved = resolveEnvValue(ctx, key, value);
-      consola.info(`Setting \`${key}\` env variable to \`${resolved}\`.`);
-      process.env[key] = resolved;
-    }
-  });
-};
-
-// Given env variable name patterns and HTTP config, return a define plugin config
-export const resolveDefineConfig = (
-  patterns: string[],
-  httpConfig?: object,
-  builder?: 'webpack' | 'vite',
-): Record<string, string> =>
-  Object.entries(process.env)
-    .filter(([key]) => patterns.some((pattern) => key.match(pattern)))
-    .reduce(
-      (acc, [key, value]) => {
-        acc[key] = JSON.stringify(value);
-        return acc;
-      },
-      {
-        NODE_ENV: JSON.stringify(process.env.NODE_ENV),
-        HTTP_CONFIG: JSON.stringify(httpConfig || ''),
-        BUILDER: JSON.stringify(builder ?? ''),
-      },
-    );

package/src/utils/federation.ts

@@ -1,40 +0,0 @@
-import { camelCase } from 'change-case';
-import type { PackageJson } from 'pkg-types';
-import { loadPackageJSONFiles } from './npm';
-
-export const getFederatedPkgName = (pkgName = '') => camelCase(pkgName.split('/').pop());
-
-const getRemoteEntry = (name, port, host = 'localhost') =>
-  `${name}@http://${host}:${port}/remoteEntry.js`;
-
-const resolveFederatedRemotes = async (packages = []) => {
-  const packageJSONFiles = await loadPackageJSONFiles(packages);
-  return (await Promise.all(packageJSONFiles)).reduce((acc, packageJSON) => {
-    const name = getFederatedPkgName(packageJSON.name);
-    const port = packageJSON.config?.PORT;
-    acc[name] = getRemoteEntry(name, port);
-    return acc;
-  }, {});
-};
-
-const resolveSharedRemotes = (packages = [], packageJSON: PackageJson) =>
-  packages.reduce((acc, p) => {
-    acc[p] = {
-      singleton: true,
-      requiredVersion: packageJSON.dependencies[p],
-    };
-    return acc;
-  }, {});
-
-export const resolveFederationConfig = async (
-  federation = { remotes: [], shared: [] },
-  packageJSON: PackageJson,
-) => {
-  const remotes = await resolveFederatedRemotes(federation.remotes);
-  const shared = resolveSharedRemotes(federation.shared, packageJSON);
-  return {
-    ...federation,
-    remotes,
-    shared,
-  };
-};

package/src/utils/fs.ts

@@ -1,53 +0,0 @@
-import type { PathLike, Stats } from 'node:fs';
-import { readdirSync, statSync, renameSync } from 'node:fs';
-import { basename, dirname, extname, resolve } from 'node:path';
-import { rimraf } from 'rimraf';
-
-/**
- * Deletes one or more provided paths
- */
-export const rm = async (paths: string | string[]) =>
-  // We can add support for globbing or filtering in the future
-  // See https://github.com/isaacs/rimraf#rimraff-opts---promise for all options
-  rimraf(paths);
-
-export const rename = (oldPath: PathLike, newPath: PathLike) => renameSync(oldPath, newPath);
-
-export interface fsEntry {
-  path: string; // full path
-  base: string; // last portion of a path, similar to the Unix basename command
-  ext: string; // file extension, if present
-  dir: string; // directory name of a path, similar to the Unix dirname command
-  isDir: boolean; // whether entry is a directory
-  stats: Stats; // Stats object
-}
-
-export const listAllFiles = (
-  startPath,
-  filter = (item: fsEntry) => true,
-  mapper = (item: fsEntry): fsEntry => item,
-): string[] => {
-  const filenames = new Set<string>();
-  const walk = (dirPath) => {
-    const files = readdirSync(dirPath);
-    for (const file of files) {
-      const fullPath = resolve(dirPath, file);
-      const stats = statSync(fullPath);
-      const isDir = stats.isDirectory();
-      const base = basename(fullPath);
-      const ext = isDir ? null : extname(fullPath).toLowerCase();
-      const dir = dirname(fullPath);
-      const entry = mapper({ path: fullPath, isDir, base, ext, dir, stats });
-
-      if (filter(entry)) {
-        if (isDir) {
-          walk(entry.path);
-        } else {
-          filenames.add(entry.path);
-        }
-      }
-    }
-  };
-  walk(startPath);
-  return [...filenames];
-};

package/src/utils/handlebars.ts

@@ -1,61 +0,0 @@
-import { PathOrFileDescriptor, readFileSync, writeFileSync } from 'node:fs';
-import {
-  camelCase,
-  capitalCase,
-  constantCase,
-  dotCase,
-  paramCase,
-  pascalCase,
-  pathCase,
-  sentenceCase,
-  snakeCase,
-} from 'change-case';
-import handlebars from 'handlebars';
-
-/*
-| Method            | Result      |
-| ----------------- | ----------- |
-| `camelCase`       | `twoWords`  |
-| `capitalCase`     | `Two Words` |
-| `constantCase`    | `TWO_WORDS` |
-| `dotCase`         | `two.words` |
-| `kebabCase`       | `two-words` |
-| `lowerCase`       | `two words` |
-| `pascalCase`      | `TwoWords`  |
-| `pathCase`        | `two/words` |
-| `sentenceCase`    | `Two words` |
-| `snakeCase`       | `two_words` |
-| `upperCase`       | `TWO_WORDS` |
-*/
-
-handlebars.registerHelper('camelCase', (s) => s && camelCase(s));
-handlebars.registerHelper('capitalCase', (s) => s && capitalCase(s));
-handlebars.registerHelper('constantCase', (s) => s && constantCase(s));
-handlebars.registerHelper('dotCase', (s) => s && dotCase(s));
-handlebars.registerHelper('kebabCase', (s) => s && paramCase(s));
-handlebars.registerHelper('lowerCase', (s) => s && s.toLowerCase());
-handlebars.registerHelper('pascalCase', (s) => s && pascalCase(s));
-handlebars.registerHelper('pathCase', (s) => s && pathCase(s));
-handlebars.registerHelper('sentenceCase', (s) => s && sentenceCase(s));
-handlebars.registerHelper('snakeCase', (s) => s && snakeCase(s));
-handlebars.registerHelper('upperCase', (s) => s && s.toUpperCase());
-handlebars.registerHelper('ifEquals', (arg1, arg2, options) => {
-  return arg1 === arg2 ? options.fn(this) : options.inverse(this);
-});
-
-export const render = (template, data) => handlebars.compile(template)(data);
-
-export const renderFile = (
-  file: PathOrFileDescriptor,
-  data: object,
-  templateFile?: PathOrFileDescriptor,
-) => {
-  const template = readFileSync(templateFile || file, 'utf8');
-  const output = render(template, data);
-  writeFileSync(file, output, 'utf8');
-};
-
-export const registerPartial = (name: string, templateFile) => {
-  const template = readFileSync(templateFile, 'utf8');
-  handlebars.registerPartial(name, template);
-};

package/src/utils/https.ts

@@ -1,29 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import consola from 'consola';
-
-/**
- * @public
- */
-export type DevCertOptions = {
-  cert: Buffer;
-  key: Buffer;
-};
-
-/**
- * Get default dev cert options.
- *
- * @public
- */
-export const getDevCertOptions = (): DevCertOptions | undefined => {
-  const certDir = resolve(__dirname, '../../cert/');
-  const cert = resolve(certDir, 'localhost.crt');
-  const key = resolve(certDir, 'localhost.key');
-  if (existsSync(cert) && existsSync(key)) {
-    return {
-      cert: readFileSync(cert),
-      key: readFileSync(key),
-    };
-  }
-  consola.warn(`Could not load the default development certificates from ${certDir}.`);
-};

package/src/utils/index.ts

@@ -1,21 +0,0 @@
-export * from './args';
-export * from './archive';
-export * from './build-context';
-export * from './child-process';
-export * from './config';
-export * from './console';
-export * from './env';
-export * from './federation';
-export * from './fs';
-export * from './handlebars';
-export * from './https';
-export * from './json';
-export * from './npm';
-export * from './prompts';
-export * from './proxy';
-export * from './object';
-export * from './seed.fetching';
-export * from './seed.meta';
-export * from './seed.processing';
-export * from './seed.setup';
-export * from './time';

package/src/utils/json.ts

@@ -1,12 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import consola from 'consola';
-
-export { default as editJSONFile } from 'edit-json-file';
-
-export const writeJSON = (path, data) => {
-  try {
-    writeFileSync(path, JSON.stringify(data, null, 2));
-  } catch (e) {
-    consola.error(`Error writing to ${path}`);
-  }
-};

package/src/utils/npm.ts

@@ -1,155 +0,0 @@
-import { execSync } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import consola from 'consola';
-import jiti from 'jiti';
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
-import type { PackageJson } from 'pkg-types';
-import type { BuildContext } from '../types';
-
-// Attempt to load id.{js,json,ts} file
-export const tryRequire = (id, rootDir = process.cwd()) => {
-  const _require = jiti(rootDir, { interopDefault: true, esmResolve: true });
-  try {
-    return _require(id);
-  } catch (error) {
-    if (error.code !== 'MODULE_NOT_FOUND') {
-      consola.error(`Error trying import ${id} from ${rootDir}`, error);
-    }
-    return null;
-  }
-};
-
-export const resolveBin = async (bin: string, module: string = bin) => {
-  const modulePath = require.resolve(module);
-  const dir = dirname(await resolvePackageJSON(modulePath));
-  const json = await readPackageJSON(modulePath);
-  const path = typeof json.bin === 'string' ? json.bin : (json.bin as Record<string, string>)[bin];
-  if (!path || !dir) {
-    throw new Error(`Could not resolve ${bin} / ${module}: ${dir} ${path}`);
-  }
-  return resolve(dir, path);
-};
-
-export const loadPackageJSON = async (dir?: string): Promise<PackageJson> => {
-  const pkg = (await readPackageJSON(dir)) || {};
-  const nameParts = (pkg.name || '').split('/');
-  // @scope/name -> name
-  // name -> name
-  pkg.nameUnscoped = nameParts.pop();
-  // @scope/name -> @scope
-  // name -> undefined
-  pkg.nameScope = nameParts.shift();
-  return pkg;
-};
-
-export const loadPackageJSONFiles = async (packages = []): Promise<PackageJson[]> =>
-  Promise.all(
-    packages.map((p) => {
-      const dir = dirname(require.resolve(p));
-      return loadPackageJSON(dir);
-    }),
-  );
-
-/*
-Given package name and range (e.g. '^14.0.1', '~14.0.1' or 'latest', return latest matching version)
-
-Registry response varies depending on whether a single or multiple versions are available.
-We return the single version which is the latest available.
-
-Response if a single version is available:
-'14.41.1'
-
-Response if multiple versions available:
-@genesislcap/genx@14.41.0 '14.41.0'
-@genesislcap/genx@14.41.1 '14.41.1'
-*/
-export const getLatestVersion = (name, range = 'latest', verbose = true) => {
-  let result;
-
-  try {
-    result = execSync(`npm info ${name}@${range} version`, {
-      stdio: ['pipe', 'pipe', 'ignore'],
-    })
-      .toString('utf8')
-      .trim()
-      .split('\n')
-      .pop()
-      .split(' ')
-      .pop()
-      .replace(/'/g, '');
-  } catch (e) {
-    if (verbose) {
-      consola.error(`Could not fetch ${name} version ${range} information from the registry`);
-    }
-  }
-
-  return result;
-};
-
-// given package version (^14.0.0, ~14.0.0), return range specifier (^, ~)
-export const getRangeSpecifier = (version) => {
-  const match = version.toString().match(/^[><=^~*]+/);
-  return (match && match[0]) || '';
-};
-
-// Return package.json without additional fields added by us
-export const getRawPkg = (ctx: BuildContext) => {
-  const { nameUnscoped, nameScope, ...pkg } = ctx.pkg;
-  return pkg;
-};
-
-export const updatePackageJSON = async (pkg: PackageJson) => {
-  const pkgJSONPath = await resolvePackageJSON();
-  try {
-    writeFileSync(pkgJSONPath, `${JSON.stringify(pkg, null, 2)}\n`);
-  } catch (e) {
-    consola.error(`Error updating package.json: ${pkgJSONPath}`, e);
-  }
-};
-
-const updateVersionType = (
-  deps: Record<string, string>,
-  newVersion: string,
-  exclude: string[],
-  include: string[] = ['@genesislcap'],
-): { name: string; to: string; from: string }[] => {
-  const updates = [];
-
-  Object.entries(deps || {}).forEach(([name, version = '']) => {
-    if (
-      include.some((pattern) => name.includes(pattern)) &&
-      exclude.every((pattern) => !name.includes(pattern))
-    ) {
-      const available = newVersion || getLatestVersion(name, version);
-      if (!available) {
-        return;
-      }
-      const rangeSpecifier = getRangeSpecifier(version);
-      const versionNew = `${rangeSpecifier}${available}`;
-
-      if (version !== versionNew) {
-        updates.push({
-          name,
-          from: version,
-          to: versionNew,
-        });
-        deps[name] = versionNew;
-      }
-    }
-  });
-
-  return updates;
-};
-
-export const updateVersions = (
-  pkg: PackageJson,
-  newVersion: string,
-  exclude: string[],
-  include: string[] = ['@genesislcap'],
-) => {
-  const deps = updateVersionType(pkg.dependencies, newVersion, exclude, include);
-  const devDeps = updateVersionType(pkg.devDependencies, newVersion, exclude, include);
-  const peerDeps = updateVersionType(pkg.peerDependencies, newVersion, exclude, include);
-  return [...deps, ...devDeps, ...peerDeps];
-};

package/src/utils/object.ts

@@ -1,21 +0,0 @@
-import { snakeCase } from 'change-case';
-
-export const objToSnakeCase = (obj: unknown) =>
-  Object.keys(obj).reduce((acc, key) => {
-    const keyRenamed = snakeCase(key);
-    acc[keyRenamed] = obj[key];
-    return acc;
-  }, {});
-
-export const replaceObjectKeys = (input, searchValue, replaceValue) =>
-  Object.fromEntries(
-    Object.entries(input).map(([key, value]) => [key.replace(searchValue, replaceValue), value]),
-  );
-
-export const excludeObjKeys = (obj: unknown, excludeKeys: string[]) =>
-  Object.keys(obj).reduce((acc, key) => {
-    if (!excludeKeys.includes(key)) {
-      acc[key] = obj[key];
-    }
-    return acc;
-  }, {});