@ultimat3/cli 21.0.0 → 22.1.0

package/src/i18n-index.ts

@@ -10,7 +10,8 @@
 // whether to write at all, before any await the caller could interleave with.
 import { existsSync } from 'node:fs';
 import { containedPath } from './generate-write';
-import { CATALOG_ROOT, i18nIndex } from './templates';
+import type { Finding } from './output';
+import { CATALOG_ROOT, i18nIndex, localeEntry, localeImport } from './templates';
 
 export const I18N_INDEX_PATH = 'packages/i18n/src/index.ts';
 
@@ -25,16 +26,64 @@ export async function catalogLocales(root: string): Promise<readonly string[]> {
   return locales.sort();
 }
 
+/** What a sync did: whether every catalog on disk is now selectable, and why not when it is not. */
+export interface IndexSync {
+  /** False for an app with no i18n package, or an index this writer refused to edit. */
+  readonly registered: boolean;
+  readonly findings: readonly Finding[];
+}
+
+const CATALOG_IMPORT = /^import (\w+) from '\.\.\/catalogs\/([^']+)\.json';$/gm;
+const LOCALES_OBJECT = /(locales:\s*\{)([^{}]*)(\})/;
+
+/** The tags the index imports a catalog for, in file order. */
+const importedLocales = (source: string): readonly string[] =>
+  [...source.matchAll(CATALOG_IMPORT)].map((match) => match[2] ?? '');
+
 /**
- * Re-derives the FULL locale set from `packages/i18n/catalogs/` — never just the locale one
- * invocation asked for — and rewrites the index to match. It bypasses `writeFiles` on purpose:
- * this file is a projection of the catalog directory, never app-authored content a conflict check
- * should protect. An app with no i18n package (deleted, or never scaffolded) is left alone, and
- * that is what `written` reports.
+ * Makes every catalog on disk selectable, and touches the index no more than that takes.
+ *
+ * An index that IS the template's output (for the locales it imports) is the framework's file and
+ * is re-derived whole. Anything else is the author's: each missing locale gets its import and its
+ * `locales: { … }` entry and nothing else moves — the declared `default`, and any code beside it,
+ * stay. A shape with no `locales: { … }` object to add to is refused with the edit named, never
+ * overwritten: it was, on every `x g`, with a template hard-coding `default: 'en'`.
  */
-export async function syncI18nIndex(root: string): Promise<boolean> {
+export async function syncI18nIndex(root: string): Promise<IndexSync> {
   const indexAbsolute = containedPath(root, I18N_INDEX_PATH);
-  if (!existsSync(indexAbsolute)) return false;
-  await Bun.write(indexAbsolute, i18nIndex(await catalogLocales(root)));
-  return true;
+  if (!existsSync(indexAbsolute)) return { registered: false, findings: [] };
+  const current = await Bun.file(indexAbsolute).text();
+  const onDisk = await catalogLocales(root);
+  const imported = importedLocales(current);
+  if (current === i18nIndex(imported)) {
+    await Bun.write(indexAbsolute, i18nIndex(onDisk));
+    return { registered: true, findings: [] };
+  }
+  const missing = onDisk.filter((locale) => !imported.includes(locale));
+  if (missing.length === 0) return { registered: true, findings: [] };
+  const edited = withLocales(current, missing);
+  if (edited === undefined) return { registered: false, findings: [refusal(missing)] };
+  await Bun.write(indexAbsolute, edited);
+  return { registered: true, findings: [] };
+}
+
+/** Each import after the last catalog import (or at the top), each entry at the object's end. */
+function withLocales(source: string, locales: readonly string[]): string | undefined {
+  const object = LOCALES_OBJECT.exec(source);
+  if (object === null) return undefined;
+  const body = (object[2] ?? '').trim().replace(/,$/, '');
+  const entries = [body, ...locales.map(localeEntry)].filter((part) => part !== '').join(', ');
+  const withEntries = source.replace(LOCALES_OBJECT, `$1 ${entries} $3`);
+  const imports = locales.map(localeImport).join('\n');
+  const lastImport = [...withEntries.matchAll(CATALOG_IMPORT)].at(-1);
+  if (lastImport === undefined) return `${imports}\n${withEntries}`;
+  const at = lastImport.index + lastImport[0].length;
+  return `${withEntries.slice(0, at)}\n${imports}${withEntries.slice(at)}`;
 }
+
+const refusal = (locales: readonly string[]): Finding => ({
+  code: 'X_CATALOG_UNREGISTERED',
+  cause: `${I18N_INDEX_PATH} is hand-written in a shape this writer cannot add ${locales.join(', ')} to, so those catalogs are on disk and not selectable`,
+  fix: `edit ${I18N_INDEX_PATH} — add ${locales.map(localeImport).join(' ')} and ${locales.map(localeEntry).join(', ')} to the locales passed to defineCatalogs`,
+  at: I18N_INDEX_PATH,
+});

package/src/icon-assets.ts

@@ -1,6 +1,6 @@
 // Single responsibility: the one source image every generated icon derives from, where the matrix
 // is served, and the renderer that turns one into the other. Its own module so the two things that
-// need it — `dev-assets.ts`, which SERVES the matrix, and `pwa-artifacts.ts`, which NAMES it in the
+// need it — `runtime-assets.ts`, which SERVES the matrix, and `pwa-artifacts.ts`, which NAMES it in the
 // web manifest — can share it without importing each other.
 
 // why: Bun exposes no path-join primitive, and `ICON_SOURCE` is app-root-relative, so resolving it

package/src/image-prepare.ts

@@ -0,0 +1,14 @@
+// What `x build --target docker` does before `docker build`: stamp the image with the manifest's
+// build id and write the island chunks it will serve (`island-store.ts`), so a container boot
+// neither re-derives the one nor rebuilds the other.
+
+import { appManifest } from './app-manifest';
+import { buildIslands } from './island-bundle';
+import { writeIslandStore } from './island-store';
+
+/** Writes `.x/islands/` and answers the build id the image is stamped with. */
+export async function prepareImage(root: string): Promise<string> {
+  const { manifest } = await appManifest(root);
+  await writeIslandStore(root, await buildIslands(root));
+  return manifest.buildId;
+}

package/src/import-scan.ts

@@ -0,0 +1,63 @@
+// The one import scanner: Bun's transpiler, fed the source with type-only imports rewritten so it
+// reports them too. A leaf — it imports nothing — so `scripts/boundaries.ts`, which must run with
+// no `node_modules`, reads it by path. A regex scanner beside it read a nested template's
+// `import … from '@ultimat3/ui'` as the generator's own import (#493); the transpiler never does.
+
+/** A file as the scanners take it: repo-relative POSIX path and its text. */
+export interface ScannedFile {
+  readonly path: string;
+  readonly source: string;
+}
+
+/** The transpiler rejects a shebang, and a `bin.ts` legitimately has one. */
+export const stripShebang = (source: string): string =>
+  source.startsWith('#!') ? source.slice(source.indexOf('\n') + 1) : source;
+
+/**
+ * `scanImports` ERASES `import type` / `export type`. Dropping the keyword before the parse makes
+ * the transpiler report one as an ordinary import. The lookahead keeps `export type Foo = string`
+ * — an alias, not an import — from becoming a syntax error.
+ */
+const TYPE_ONLY_CLAUSE = /\b(import|export)\s+type\s+(?=[{*]|[A-Za-z_$][\w$]*\s+from\b)/g;
+
+export const dropTypeKeyword = (source: string): string => source.replace(TYPE_ONLY_CLAUSE, '$1 ');
+
+/**
+ * The inline spelling `import { type Foo } from 'x'`, whose whole list is type-only and so erased.
+ * The list is DELETED rather than de-`type`d — deciding which `type` is a modifier is the parser's
+ * job — and a side-effect import carries the one thing a scan reads, the specifier.
+ */
+const BRACE_IMPORT =
+  /(^|[\s;}])(?:import|export)\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{[^{}]*\}\s*from\s*(['"])([^'"\n]+)\2/g;
+
+export const asSideEffectImports = (source: string): string =>
+  source.replace(BRACE_IMPORT, '$1import $2$3$2');
+
+const loaderOf = (path: string): 'ts' | 'tsx' => (path.endsWith('x') ? 'tsx' : 'ts');
+
+/** What survives type erasure: static, re-export, side-effect and dynamic imports, and `require`. */
+export function scanRuntimeImports(file: ScannedFile): readonly string[] {
+  return new Bun.Transpiler({ loader: loaderOf(file.path) })
+    .scanImports(stripShebang(file.source))
+    .map((entry) => entry.path);
+}
+
+/**
+ * Every specifier the file names, type-only ones included. Throws when the file does not parse —
+ * a scan that answered `[]` there would read as a file importing nothing. The rewrite pass alone
+ * is forgiving: a rewrite the parser refuses falls back to the runtime scan.
+ */
+export function scanAllImports(file: ScannedFile): readonly string[] {
+  const runtime = scanRuntimeImports(file);
+  let typed: readonly string[] = [];
+  try {
+    const rewritten = asSideEffectImports(dropTypeKeyword(stripShebang(file.source)));
+    typed = new Bun.Transpiler({ loader: loaderOf(file.path) })
+      .scanImports(rewritten)
+      .map((entry) => entry.path);
+  } catch {
+    typed = [];
+  }
+  // The rewritten pass first: it holds every import in SOURCE order, which callers report in.
+  return [...new Set([...typed, ...runtime])];
+}