@apollion-dsi/scripts 0.8.1 → 0.9.1

package/src/command/validate.ts

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import spawn from 'cross-spawn';
+
+/**
+ * `scripts validate` — Apollion's standard pre-merge gate. Runs
+ * `check-types`, `prettier --check`, `lint` (parallel) then `test`
+ * with `--watchAll=false` (sequential). Bails on the first failure.
+ *
+ * Mirrors the Apollion ecosystem's own `scripts/validate.sh`
+ * orchestration so consumers don't have to reinvent it.
+ */
+const userArgs = process.argv.slice(2);
+
+const skip = new Set(
+  userArgs.filter((arg) => arg.startsWith('--skip=')).flatMap((arg) => arg.slice('--skip='.length).split(',')),
+);
+
+type Step = { name: string; cmd: string };
+
+const parallel: Step[] = [
+  { name: 'check-types', cmd: 'check-types' },
+  { name: 'prettier', cmd: 'prettier' },
+  { name: 'lint', cmd: 'lint' },
+].filter((s) => !skip.has(s.name));
+
+const sequential: Step[] = [{ name: 'test', cmd: 'test --watchAll=false' }].filter((s) => !skip.has(s.name));
+
+function runStep(step: Step): Promise<number> {
+  return new Promise((resolve) => {
+    console.log(chalk.cyan(`▶ ${step.name}`));
+
+    const [bin, ...rest] = step.cmd.split(' ');
+
+    const child = spawn(process.execPath, [require.resolve(`./${bin}`), ...rest], {
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+(async () => {
+  const parallelResults = await Promise.all(parallel.map(runStep));
+
+  const parallelFailures = parallel.filter((_, i) => parallelResults[i] !== 0);
+
+  if (parallelFailures.length > 0) {
+    console.error(chalk.red(`✘ validate failed: ${parallelFailures.map((s) => s.name).join(', ')}`));
+
+    process.exit(1);
+  }
+
+  for (const step of sequential) {
+    const code = await runStep(step);
+
+    if (code !== 0) {
+      console.error(chalk.red(`✘ validate failed: ${step.name}`));
+
+      process.exit(code);
+    }
+  }
+
+  console.log(chalk.green('✓ validate passed'));
+
+  process.exit(0);
+})();

package/src/utils/buildWrapperArgs.ts

@@ -0,0 +1,37 @@
+/**
+ * Build the argv passed to an underlying CLI (eslint, prettier) for a
+ * `scripts <cmd>` wrapper, from the user-provided argv.
+ *
+ * - Empty input → `defaults` verbatim (the canonical no-args
+ *   invocation, e.g. `['src', '--quiet']` for lint).
+ * - Non-empty input → user args (with the POSIX `--` end-of-options
+ *   marker removed) followed by `target`.
+ *
+ * The previous heuristic tried to detect "user-provided path" by
+ * scanning for any argv entry not starting with `-`, then handed full
+ * control to the user. That broke two real consumer invocations:
+ *
+ * 1. `scripts lint --max-warnings 0` — the `0` value of the flag was
+ *    misread as a path, so `src` was dropped and ESLint ran with no
+ *    files.
+ * 2. `scripts lint -- --fix` — every arg started with `-`, so `src`
+ *    was appended, but the surviving `--` separator forced ESLint to
+ *    treat `--fix` and `src` as positional files.
+ *
+ * The wrapper is intentionally narrow: pass flags, get the default
+ * target. Consumers that need a non-default target should invoke the
+ * underlying CLI directly (`node_modules/.bin/eslint <path>`).
+ *
+ * @param userArgs - argv after `scripts <cmd>` (i.e. `process.argv.slice(2)`).
+ * @param options.defaults - argv to use when `userArgs` is empty.
+ * @param options.target - path/glob appended after user flags otherwise.
+ */
+export function buildWrapperArgs(userArgs: string[], options: { defaults: string[]; target: string }): string[] {
+  if (userArgs.length === 0) {
+    return [...options.defaults];
+  }
+
+  const passthrough = userArgs.filter((a) => a !== '--');
+
+  return [...passthrough, options.target];
+}

package/src/utils/resolveBin.ts

@@ -0,0 +1,36 @@
+import { createRequire } from 'module';
+import path from 'path';
+
+/**
+ * Resolve the absolute path to a dependency's CLI entrypoint as declared
+ * in its `package.json#bin`. Works for packages whose `exports` map
+ * blocks `require.resolve('<pkg>/bin/...')` (e.g. eslint 9+).
+ *
+ * @param pkgName - dependency name (e.g. `'eslint'`, `'prettier'`)
+ * @param binName - bin name when `package.json#bin` is an object map.
+ *   Defaults to `pkgName`.
+ * @param fromPath - directory to resolve `pkgName` from. Defaults to
+ *   this file's directory so production calls walk up from
+ *   `@apollion-dsi/scripts`'s install location.
+ */
+export function resolveBin(pkgName: string, binName: string = pkgName, fromPath: string = __dirname): string {
+  const req = createRequire(path.join(fromPath, 'noop.js'));
+
+  const pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+
+  const pkgJson = req(pkgJsonPath) as { bin?: string | Record<string, string> };
+
+  const binField = pkgJson.bin;
+
+  if (!binField) {
+    throw new Error(`Package "${pkgName}" has no "bin" field in package.json`);
+  }
+
+  const relBin = typeof binField === 'string' ? binField : binField[binName];
+
+  if (!relBin) {
+    throw new Error(`Package "${pkgName}" has no bin named "${binName}"`);
+  }
+
+  return path.resolve(path.dirname(pkgJsonPath), relBin);
+}

package/template/src/App.tsx

@@ -1,5 +1,8 @@
-import { ApollionProvider, Button, Flex, GlobalStyle, Text, useNotification } from '@apollion-dsi/core';
-import React from 'react';
+import { Flex } from '@apollion-dsi/core/containers/flex';
+import { useNotification } from '@apollion-dsi/core/containers/notification';
+import { Button } from '@apollion-dsi/core/elements/button';
+import { Text } from '@apollion-dsi/core/elements/text';
+import { ApollionProvider, GlobalStyle } from '@apollion-dsi/core/themes';
 
 function App() {
   const { showNotification } = useNotification();

package/template/src/index.tsx

@@ -1,10 +1,12 @@
-import React from 'react';
-import { render } from 'react-dom';
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
 import { Root } from './App';
 
-render(
-  <React.StrictMode>
+const container = document.getElementById('root');
+if (!container) throw new Error('Root container #root not found');
+
+createRoot(container).render(
+  <StrictMode>
     <Root />
-  </React.StrictMode>,
-  document.getElementById('root'),
+  </StrictMode>,
 );

package/template/tsconfig.json

@@ -1,25 +1,4 @@
 {
-  "compilerOptions": {
-    "target": "es5",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "module": "esnext",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react"
-  },
-  "include": [
-    "src"
-  ]
-}
+  "extends": "@apollion-dsi/scripts/tsconfig.base.json",
+  "include": ["src"]
+}

package/tsconfig.base.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "es2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noEmit": true
+  }
+}

package/template/audit-ci.json

@@ -1,5 +0,0 @@
-{
-  "high": true,
-  "package-manager": "yarn",
-  "report-type": "summary"
-}