rimecms 0.31.4 → 0.32.0

package/dist/core/dev/codegen/routes/util.server.d.ts

@@ -0,0 +1,52 @@
+import type { Config } from '../../../config/types.js';
+/**
+ * Types for route definitions
+ */
+export type RouteTemplateFunction<T extends any[] = any[]> = (...args: T) => string;
+export type RouteDefinition = Record<string, RouteTemplateFunction>;
+export type Routes = Record<string, RouteDefinition>;
+/**
+ * Whether the generated route tree still matches what the config and the package would produce.
+ *
+ * Everything `generateRoutes` reads has to appear here, or a change to it writes nothing and the
+ * app runs against the previous tree — a route that answers 404 with no error saying why.
+ *
+ * ```
+ * panel, config   baked into the param matchers and the layouts' config import path
+ * custom, css     written straight from config.panel
+ * prototypes      the slug lists the [slug=<name>] matchers accept
+ * rest            one +server.ts per prototype route path, and the methods it exports
+ * version         the templates every file above is written from ship with the package
+ * ```
+ *
+ * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes
+ * effect after a restart — and only if that restart's regen notices it.
+ *
+ * @returns true if routes should be regenerated, false otherwise
+ */
+export declare function shouldRegenerateRoutes<T extends Config>(config: T): boolean;
+/**
+ * Creates a directory if it doesn't exist
+ * @example
+ * // Ensure a directory exists
+ * const dirPath = '/path/to/directory';
+ * ensureDir(dirPath);
+ * // The directory will be created if it doesn't exist
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Writes a route file with its content
+ * @param basePath The base path where routes are generated
+ * @param routePath The specific route path
+ * @param fileType The type of file to generate (page, pageServer, layout, layoutServer)
+ * @param content The content to write to the file
+ * @example
+ * // Write a page file for a collection
+ * const basePath = '/path/to/src/routes';
+ * const routePath = '(rime)/[panel=panel]/news';
+ * const fileType = 'page';
+ * const content = '<script>\n  import { Collection } from "rime/panel"\n</script>...';
+ * writeRouteFile(basePath, routePath, fileType, content);
+ * // Creates /path/to/src/routes/(rime)/[panel=panel]/news/+page.svelte with the provided content
+ */
+export declare function writeRouteFile(basePath: string, routePath: string, fileType: string, content: string): void;

package/dist/core/dev/codegen/routes/util.server.js

@@ -0,0 +1,118 @@
+import cache from '../../cache.server.js';
+import { CONFIG_DIR } from '../../constants.server.js';
+import { restSurface } from '../../prototype-routes.server.js';
+import { rimeVersion } from '../../version.server.js';
+import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import { slugify } from '../../../../util/string.js';
+import fs from 'fs';
+import path from 'path';
+/**
+ * Whether the generated route tree still matches what the config and the package would produce.
+ *
+ * Everything `generateRoutes` reads has to appear here, or a change to it writes nothing and the
+ * app runs against the previous tree — a route that answers 404 with no error saying why.
+ *
+ * ```
+ * panel, config   baked into the param matchers and the layouts' config import path
+ * custom, css     written straight from config.panel
+ * prototypes      the slug lists the [slug=<name>] matchers accept
+ * rest            one +server.ts per prototype route path, and the methods it exports
+ * version         the templates every file above is written from ship with the package
+ * ```
+ *
+ * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes
+ * effect after a restart — and only if that restart's regen notices it.
+ *
+ * @returns true if routes should be regenerated, false otherwise
+ */
+export function shouldRegenerateRoutes(config) {
+    const memo = `
+    panel:${PANEL_ROUTE}
+    config:${CONFIG_DIR}
+    custom:${config.panel?.routes
+        ? Object.entries(config.panel.routes)
+            .map(([k, v]) => `${k}-${slugify(v.component.toString())}`)
+            .join(',')
+        : ''}
+    css:${config.panel?.css ? config.panel.css : 'none'}
+    prototypes:${[...(config.collections || []), ...(config.areas || [])]
+        .map((p) => `${p.type}:${p.slug}`)
+        .join(',')}
+    rest:${restSurface()}
+    version:${rimeVersion()}
+  `;
+    if (cache.matches('routes', memo))
+        return false;
+    cache.remember('routes', memo);
+    return true;
+}
+/**
+ * Creates a directory if it doesn't exist
+ * @example
+ * // Ensure a directory exists
+ * const dirPath = '/path/to/directory';
+ * ensureDir(dirPath);
+ * // The directory will be created if it doesn't exist
+ */
+export function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Writes a route file with its content
+ * @param basePath The base path where routes are generated
+ * @param routePath The specific route path
+ * @param fileType The type of file to generate (page, pageServer, layout, layoutServer)
+ * @param content The content to write to the file
+ * @example
+ * // Write a page file for a collection
+ * const basePath = '/path/to/src/routes';
+ * const routePath = '(rime)/[panel=panel]/news';
+ * const fileType = 'page';
+ * const content = '<script>\n  import { Collection } from "rime/panel"\n</script>...';
+ * writeRouteFile(basePath, routePath, fileType, content);
+ * // Creates /path/to/src/routes/(rime)/[panel=panel]/news/+page.svelte with the provided content
+ */
+export function writeRouteFile(basePath, routePath, fileType, content) {
+    const dir = path.join(basePath, routePath);
+    ensureDir(dir);
+    let fileName;
+    let baseType = fileType;
+    let groupName = '';
+    // Check if fileType contains a group name after @
+    if (fileType.includes('@')) {
+        const parts = fileType.split('@');
+        baseType = parts[0];
+        groupName = parts[1];
+    }
+    if (baseType === 'layout') {
+        fileName = '+layout.svelte';
+    }
+    else if (baseType === 'layoutServer') {
+        fileName = '+layout.server.ts';
+    }
+    else if (baseType === 'page') {
+        fileName = '+page.svelte';
+    }
+    else if (baseType === 'pageServer') {
+        fileName = '+page.server.ts';
+    }
+    else if (baseType === 'error') {
+        fileName = '+error.svelte';
+    }
+    else if (baseType === 'server') {
+        fileName = '+server.ts';
+    }
+    else {
+        fileName = `+${baseType}.svelte`;
+    }
+    // Insert group name before the first dot if a group name exists
+    if (groupName) {
+        const dotIndex = fileName.indexOf('.');
+        if (dotIndex !== -1) {
+            fileName = fileName.substring(0, dotIndex) + '@' + groupName + fileName.substring(dotIndex);
+        }
+    }
+    fs.writeFileSync(path.join(dir, fileName), content);
+}

package/dist/core/dev/codegen/runtime/index.server.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `$rime/modules` — one name, two files, resolved per build.
+ *
+ * A folder declares a pair and the barrel re-exports whichever half the current build wants:
+ *
+ * ```
+ * upload/module.ts          the client half
+ * upload/module.server.ts   the server half
+ * ```
+ *
+ * Only files named exactly `module.ts` or `module.server.ts` are collected, which is why a
+ * `hooks/index.server.ts` beside one is invisible to the mechanism.
+ *
+ * **Three shapes, and only the middle one bites:**
+ *
+ * ```
+ * both halves, same names        resolves per build            ← what you want
+ * both halves, name in server    NOT EXPORTED on a client build
+ * server half only               `undefined` on a client build
+ * ```
+ *
+ * The middle one fails at link time with `does not provide an export named 'x'`, and nothing
+ * static sees it — the failure is a 500 on every module request, with a message that names
+ * nothing. So a server-only name goes in a folder with **no `module.ts` beside it**, and the
+ * caller guards it:
+ *
+ * ```ts
+ * await bootUpload?.(config);
+ * ```
+ *
+ * Never move a constant to make an isomorphic file reach it. `.server` is what keeps
+ * `PRIVATE_FIELDS` out of a browser bundle; what crosses the barrel is the function, and on a
+ * client build it is `undefined` and never called.
+ */
+export type RuntimeRegistryEntry = {
+    client: string;
+    server: string;
+};
+export type RuntimeRegistry = Map<string, RuntimeRegistryEntry>;
+/**
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
+ *
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
+ */
+export declare function findInstalledPackageRoot(pkgName: string, fromDir: string): string;
+/**
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export declare function findModulePair(root: string, name: string): RuntimeRegistryEntry | null;
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-exports` (once, at prepack, scanning `dist/`).
+ *
+ * A pair sitting directly in `root` itself (e.g. `src/lib/module.ts`, no subfolder) registers
+ * under the key `.` — same convention `package.json`'s own `exports` map uses for a package's
+ * root, and a folder literally named `.` can't exist, so it can never collide with a real one.
+ *
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
+ */
+export declare function scanModulePairs(root: string): RuntimeRegistry;

package/dist/core/dev/codegen/runtime/index.server.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { OUTPUT_DIR } from '../../constants.server.js';
+/**
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
+ *
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
+ */
+export function findInstalledPackageRoot(pkgName, fromDir) {
+    let dir = fromDir;
+    while (true) {
+        const candidate = path.join(dir, 'node_modules', pkgName);
+        if (fs.existsSync(path.join(candidate, 'package.json'))) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`$rime/modules: could not find installed package '${pkgName}' above ${fromDir}`);
+        }
+        dir = parent;
+    }
+}
+/** `module.ts` when scanning TS source, `module.js` when scanning a built `dist/`. */
+function findModuleFile(dir, baseName) {
+    for (const ext of ['.ts', '.js']) {
+        const candidate = path.join(dir, `${baseName}${ext}`);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export function findModulePair(root, name) {
+    const dir = path.join(root, name);
+    const client = findModuleFile(dir, 'module');
+    const server = findModuleFile(dir, 'module.server');
+    return client || server ? { client: client ?? '', server: server ?? '' } : null;
+}
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-exports` (once, at prepack, scanning `dist/`).
+ *
+ * A pair sitting directly in `root` itself (e.g. `src/lib/module.ts`, no subfolder) registers
+ * under the key `.` — same convention `package.json`'s own `exports` map uses for a package's
+ * root, and a folder literally named `.` can't exist, so it can never collide with a real one.
+ *
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
+ */
+export function scanModulePairs(root) {
+    const registry = new Map();
+    if (!fs.existsSync(root))
+        return registry;
+    const register = (dir, key) => {
+        const client = findModuleFile(dir, 'module');
+        const server = findModuleFile(dir, 'module.server');
+        if (client || server) {
+            registry.set(key, { client: client ?? '', server: server ?? '' });
+        }
+    };
+    register(root, '.');
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === OUTPUT_DIR)
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            register(fullPath, path.relative(root, fullPath).split(path.sep).join('/'));
+            walk(fullPath);
+        }
+    };
+    walk(root);
+    return registry;
+}

package/dist/core/dev/codegen/runtime/parse-exports.server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Top-level named + default export identifiers of a module — the names a half pair's missing side
+ * has to declare as `undefined`. Read by the Vite plugin in dev and by `generate-exports` at
+ * prepack, which writes the same stub out as a file.
+ *
+ * **Values only.** A type export has no runtime existence, so collecting one is never right: it
+ * would be stubbed as `export const Foo = undefined` on a missing side, and indexed as a name a
+ * rewrite could target. Three shapes carry a type and each needs its own guard, because babel
+ * spells them differently:
+ *
+ * - `export type Foo = …` / `export interface Foo {}` — a type *declaration*, which reaches the
+ *   `'id' in node.declaration` branch below looking exactly like a function or a class.
+ * - `export type { Foo }` — `node.exportKind === 'type'` on the whole statement.
+ * - `export { type Foo, bar }` — `spec.exportKind === 'type'` on the individual specifier.
+ */
+export declare function parseExportNames(filePath: string): string[];

package/dist/core/dev/codegen/runtime/parse-exports.server.js

@@ -0,0 +1,60 @@
+import { babelParse } from 'ast-kit';
+import * as t from '@babel/types';
+import fs from 'node:fs';
+/**
+ * Top-level named + default export identifiers of a module — the names a half pair's missing side
+ * has to declare as `undefined`. Read by the Vite plugin in dev and by `generate-exports` at
+ * prepack, which writes the same stub out as a file.
+ *
+ * **Values only.** A type export has no runtime existence, so collecting one is never right: it
+ * would be stubbed as `export const Foo = undefined` on a missing side, and indexed as a name a
+ * rewrite could target. Three shapes carry a type and each needs its own guard, because babel
+ * spells them differently:
+ *
+ * - `export type Foo = …` / `export interface Foo {}` — a type *declaration*, which reaches the
+ *   `'id' in node.declaration` branch below looking exactly like a function or a class.
+ * - `export type { Foo }` — `node.exportKind === 'type'` on the whole statement.
+ * - `export { type Foo, bar }` — `spec.exportKind === 'type'` on the individual specifier.
+ */
+export function parseExportNames(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+    const names = [];
+    for (const node of ast.body) {
+        if (t.isExportNamedDeclaration(node)) {
+            // `export type { Foo }` — the whole statement is type-only.
+            if (node.exportKind === 'type')
+                continue;
+            if (node.declaration) {
+                if (t.isVariableDeclaration(node.declaration)) {
+                    for (const decl of node.declaration.declarations) {
+                        if (t.isIdentifier(decl.id))
+                            names.push(decl.id.name);
+                    }
+                }
+                else if (
+                // A type alias or an interface declares an `id` just like a function does, so the
+                // shape test below cannot tell them apart — these two are the discriminator.
+                !t.isTSTypeAliasDeclaration(node.declaration) &&
+                    !t.isTSInterfaceDeclaration(node.declaration) &&
+                    'id' in node.declaration &&
+                    node.declaration.id &&
+                    t.isIdentifier(node.declaration.id)) {
+                    names.push(node.declaration.id.name);
+                }
+            }
+            for (const spec of node.specifiers) {
+                // `export { type Foo, bar }` — only this specifier is type-only.
+                if (t.isExportSpecifier(spec) && spec.exportKind === 'type')
+                    continue;
+                if (t.isExportSpecifier(spec) && t.isIdentifier(spec.exported)) {
+                    names.push(spec.exported.name);
+                }
+            }
+        }
+        if (t.isExportDefaultDeclaration(node)) {
+            names.push('default');
+        }
+    }
+    return names;
+}