@haystackeditor/cli 0.24.1 → 0.25.1

package/dist/capture/adapters/jsx-edit.js

@@ -0,0 +1,81 @@
+/** Placing init's tags in a JSX document (Next.js layouts and _app, React Router / Remix root): exactly once, replacing
+ * an earlier version in place, and checked by parsing the result. */
+import { applyEdits, jsxName, jsxStringAttribute, lineIndent, parseFile, startsLine, walk } from '../js-ast.js';
+import { ourScriptKind } from '../tag.js';
+export function jsxElementsNamed(ast, name) {
+    const found = [];
+    walk(ast.program, node => { if (node.type === 'JSXElement' && jsxName(node) === name)
+        found.push(node); });
+    return found;
+}
+/** init's own script elements: one of `components` (Script, script) whose src is one of init's files. */
+export function ourJsxElements(ast, components) {
+    const found = [];
+    walk(ast.program, node => {
+        if (node.type !== 'JSXElement')
+            return;
+        const name = jsxName(node);
+        const src = name !== null && components.includes(name) ? jsxStringAttribute(node, 'src') : null;
+        if (src !== null && ourScriptKind(src) !== null)
+            found.push(node);
+    });
+    return found;
+}
+function lineRange(code, node) {
+    const lineStart = code.lastIndexOf('\n', node.start - 1) + 1;
+    const lineEnd = code.indexOf('\n', node.end);
+    const end = lineEnd === -1 ? code.length : lineEnd + 1;
+    return code.slice(lineStart, node.start).trim() === '' && code.slice(node.end, end).trim() === ''
+        ? { start: lineStart, end } : { start: node.start, end: node.end };
+}
+/**
+ * Edits that leave exactly `tags` as init's elements: none when they are already there; the first earlier element
+ * replaced in place and the others removed when they differ; else inserted before `closingStart` (a `</body>`, `</head>`
+ * or `</>`), one per line at the children's indentation when the closing tag starts its own line.
+ */
+export function placeTags(code, ours, closingStart, tags, unit) {
+    if (ours.length > 0) {
+        const current = ours.map(node => code.slice(node.start, node.end));
+        if (current.length === tags.length && current.every((text, index) => text === tags[index]))
+            return [];
+        const indent = lineIndent(code, ours[0].start);
+        return [
+            { start: ours[0].start, end: ours[0].end, text: tags.join(`\n${indent}`) },
+            ...ours.slice(1).map(node => ({ ...lineRange(code, node), text: '' })),
+        ];
+    }
+    if (closingStart === null)
+        return { manual: 'there is no place for the tag' };
+    if (startsLine(code, closingStart)) {
+        const indent = lineIndent(code, closingStart) + unit;
+        const lineStart = code.lastIndexOf('\n', closingStart - 1) + 1;
+        return [{ start: lineStart, end: lineStart, text: tags.map(tag => `${indent}${tag}\n`).join('') }];
+    }
+    return [{ start: closingStart, end: closingStart, text: tags.join('') }];
+}
+/** Applies the edits and proves the result: it parses, and init's elements in it are exactly `tags`. */
+export function checkedResult(code, file, edits, components, tags) {
+    const next = applyEdits(code, edits);
+    const ast = parseFile(next, file);
+    if (!ast)
+        return { manual: 'the edited file would not parse' };
+    const placed = ourJsxElements(ast, components).map(node => next.slice(node.start, node.end));
+    if (placed.length !== tags.length || placed.some((text, index) => text !== tags[index])) {
+        return { manual: 'the edit did not leave exactly one tag' };
+    }
+    return next;
+}
+/** `text` with every line after the first indented by one more `unit`, or null when the text holds a multi-line template
+ * literal or string (a JSX attribute string may span lines), whose content would change. JSX text is insensitive to the
+ * indentation of its lines. */
+export function reindented(node, code, unit) {
+    let multilineTemplate = false;
+    walk(node, inner => {
+        if ((inner.type === 'TemplateLiteral' || inner.type === 'StringLiteral') && code.slice(inner.start, inner.end).includes('\n')) {
+            multilineTemplate = true;
+        }
+    });
+    if (multilineTemplate)
+        return null;
+    return code.slice(node.start, node.end).split('\n').map((line, index) => index === 0 || line === '' ? line : `${unit}${line}`).join('\n');
+}

package/dist/capture/adapters/next-build.js

@@ -0,0 +1,113 @@
+/**
+ * What a Next.js production build says about its routes (CAPTURE-V1 rule 4), read after `next build` from its own output,
+ * so wrappers, conditionals and environment-set options (`basePath: process.env.BASE_PATH`, `output: isVercel ? … : …`)
+ * are what this build actually used. Formats as Next 13–16 write them (packages/next/src/build/index.ts,
+ * generate-routes-manifest.ts, shared/lib/router/utils/app-paths.ts):
+ *   <distDir>/routes-manifest.json            { version: 3, basePath, i18n?, rewrites: { beforeFiles, afterFiles, fallback }
+ *                                              (an array before Next 10), staticRoutes, dynamicRoutes, … }
+ *   <distDir>/required-server-files.json      { version: 1, config: the resolved config (pageExtensions, output, assetPrefix,
+ *                                              basePath, i18n, …), appDir, relativeAppDir, files, ignore }
+ *   <distDir>/app-path-routes-manifest.json   { "/(group)/x/[id]/page": "/x/[id]", … } (app router)
+ *   <distDir>/server/app-paths-manifest.json  { "/(group)/x/[id]/page": "app/(group)/x/[id]/page.js", … } (app router)
+ *   <distDir>/server/pages-manifest.json      { "/about": "pages/about.js", "/_app": "pages/_app.js", … } (pages router)
+ *   <distDir>/export-detail.json              { version: 1, outDirectory, success } (export/index.ts): written by a static
+ *                                              export (`output: 'export'`) inside the build, removed by any other build
+ *   <distDir>/BUILD_ID
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+import { isDirectory, isFile } from './files.js';
+/** Next's default pageExtensions (config-shared.ts), in its order of precedence. */
+export const DEFAULT_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js'];
+function json(file) {
+    if (!isFile(file))
+        return null;
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+/** The build directory: .next when it holds a build, else the one top-level directory that does (a custom distDir),
+ * the newest when several do (the build that just ran). */
+function buildDir(appDir) {
+    const holdsBuild = (dir) => isFile(join(dir, 'routes-manifest.json')) && isFile(join(dir, 'BUILD_ID'));
+    if (holdsBuild(join(appDir, '.next')))
+        return join(appDir, '.next');
+    let entries;
+    try {
+        entries = readdirSync(appDir);
+    }
+    catch {
+        return null;
+    }
+    const builds = entries.filter(entry => entry !== 'node_modules').map(entry => join(appDir, entry))
+        .filter(dir => isDirectory(dir) && holdsBuild(dir))
+        .sort((a, b) => statSync(join(b, 'BUILD_ID')).mtimeMs - statSync(join(a, 'BUILD_ID')).mtimeMs);
+    return builds[0] ?? null;
+}
+/** Next's normalizeAppPath: route groups and @slots add no segment, and the trailing /page or /route goes. */
+export function normalizeAppPath(key) {
+    const segments = key.split('/');
+    const kept = segments.filter((segment, index) => segment !== '' && !(segment.startsWith('(') && segment.endsWith(')'))
+        && !segment.startsWith('@') && !((segment === 'page' || segment === 'route') && index === segments.length - 1));
+    return `/${kept.join('/')}`;
+}
+function pageRewrites(rewrites, basePath) {
+    const list = Array.isArray(rewrites) ? rewrites
+        : rewrites && typeof rewrites === 'object'
+            ? ['beforeFiles', 'afterFiles', 'fallback'].flatMap(phase => rewrites[phase] ?? []) : [];
+    return list.filter(rewrite => {
+        if (typeof rewrite.destination !== 'string' || !rewrite.destination.startsWith('/'))
+            return false;
+        // Destinations carry the basePath; API routes, Next's own files and capture's own files (the origin-root routing a
+        // basePath build asks for) are not pages.
+        const path = basePath !== '' && rewrite.destination.startsWith(`${basePath}/`) ? rewrite.destination.slice(basePath.length) : rewrite.destination;
+        if (path === '/api' || ['/api/', '/_next/', '/_haystack/', '/.well-known/haystack-capture/'].some(prefix => path.startsWith(prefix)))
+            return false;
+        // Intercepting routes' own rewrites (matched on the Next-Url header) keep the URL's route.
+        const has = Array.isArray(rewrite.has) ? rewrite.has : [];
+        return !has.some(condition => condition.type === 'header' && typeof condition.key === 'string' && condition.key.toLowerCase() === 'next-url');
+    }).map(rewrite => ({ source: String(rewrite.source), destination: String(rewrite.destination) }));
+}
+/** The app's production build as Next wrote it, or why there is none to read. */
+export function readNextBuild(appDir) {
+    const dir = buildDir(appDir);
+    if (dir === null)
+        return { manual: 'there is no Next.js build output (.next/routes-manifest.json) to read the routes from: run it after `next build`' };
+    const routes = json(join(dir, 'routes-manifest.json'));
+    if (routes === null)
+        return { manual: `${dir} has no routes-manifest.json` };
+    const required = json(join(dir, 'required-server-files.json'));
+    // The export this build wrote (every build removes the file before it exports, and a finished export says success),
+    // wherever it went: out/, or a custom distDir that `output: 'export'` turns into the export directory.
+    const exported = json(join(dir, 'export-detail.json'));
+    const exportPath = exported?.success === true && typeof exported.outDirectory === 'string'
+        ? (isAbsolute(exported.outDirectory) ? exported.outDirectory : join(appDir, exported.outDirectory)) : null;
+    const config = required?.config ?? {};
+    const appPathRoutes = json(join(dir, 'app-path-routes-manifest.json'));
+    const serverAppPaths = json(join(dir, 'server', 'app-paths-manifest.json'));
+    const appPaths = appPathRoutes ?? (serverAppPaths
+        ? Object.fromEntries(Object.keys(serverAppPaths).map(key => [key, normalizeAppPath(key)])) : null);
+    const locales = Array.isArray(routes.i18n?.locales) ? routes.i18n.locales.filter((locale) => typeof locale === 'string') : [];
+    const basePath = typeof routes.basePath === 'string' ? routes.basePath : '';
+    return {
+        dir,
+        basePath,
+        i18n: locales.length > 0 && typeof routes.i18n?.defaultLocale === 'string' ? { locales, defaultLocale: routes.i18n.defaultLocale } : null,
+        pageExtensions: Array.isArray(config.pageExtensions) && config.pageExtensions.every(item => typeof item === 'string')
+            ? config.pageExtensions : DEFAULT_EXTENSIONS,
+        exportDir: exportPath !== null && isDirectory(exportPath) ? relative(appDir, exportPath).split('\\').join('/') : null,
+        assetPrefix: typeof config.assetPrefix === 'string' ? config.assetPrefix : '',
+        appPaths,
+        pages: json(join(dir, 'server', 'pages-manifest.json')),
+        pageRewrites: pageRewrites(routes.rewrites, basePath),
+    };
+}
+/** The URL path the build's static files are served under (assetPrefix may be another origin, whose path still counts). */
+export function staticPathPrefix(assetPrefix) {
+    if (assetPrefix === '')
+        return '';
+    let path = assetPrefix;
+    try {
+        path = new URL(assetPrefix).pathname;
+    }
+    catch { /* a path, not a URL */ }
+    return path.replace(/\/+$/, '');
+}