rimecms 0.31.5 → 0.32.0

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

@@ -1,50 +0,0 @@
-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>;
-/**
- * Check if routes need to be regenerated based on config changes.
- * Panel/API routes are a fixed set of dynamic-segment files (file count never
- * grows with schema size), but the [panel=panel]/[slug=collection]/[slug=area]
- * param matchers under src/params/ bake in the actual accepted value(s), so
- * changing RIME_PANEL_ROUTE or RIME_CONFIG_DIR, or adding/removing/renaming a
- * collection/area, still needs a regen to keep those matchers in sync — same
- * trigger as custom routes and panel CSS. Both PANEL_ROUTE and CONFIG_DIR must
- * stay in this memo: they're read once at process start, so a changed value
- * only takes effect after a restart, and only if the restart's regen actually
- * notices the change. CONFIG_DIR specifically is baked into the panel/live
- * layout's config import path (see configImportPaths() calls in
- * common.server.ts) — leaving it out would silently keep that import stale
- * instead of erroring, the same failure mode RIME_CONFIG_DIR hit once for
- * hooks.server.ts (see regenerateHooks() in cli/init/templates.ts).
- * @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/generate/routes/util.server.js

@@ -1,112 +0,0 @@
-import cache from '../../cache/index.server.js';
-import { CONFIG_DIR, PANEL_ROUTE } from '../../constants.js';
-import { slugify } from '../../../../util/string.js';
-import fs from 'fs';
-import path from 'path';
-/**
- * Check if routes need to be regenerated based on config changes.
- * Panel/API routes are a fixed set of dynamic-segment files (file count never
- * grows with schema size), but the [panel=panel]/[slug=collection]/[slug=area]
- * param matchers under src/params/ bake in the actual accepted value(s), so
- * changing RIME_PANEL_ROUTE or RIME_CONFIG_DIR, or adding/removing/renaming a
- * collection/area, still needs a regen to keep those matchers in sync — same
- * trigger as custom routes and panel CSS. Both PANEL_ROUTE and CONFIG_DIR must
- * stay in this memo: they're read once at process start, so a changed value
- * only takes effect after a restart, and only if the restart's regen actually
- * notices the change. CONFIG_DIR specifically is baked into the panel/live
- * layout's config import path (see configImportPaths() calls in
- * common.server.ts) — leaving it out would silently keep that import stale
- * instead of erroring, the same failure mode RIME_CONFIG_DIR hit once for
- * hooks.server.ts (see regenerateHooks() in cli/init/templates.ts).
- * @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'}
-    collections:${(config.collections || []).map((c) => c.slug).join(',')}
-    areas:${(config.areas || []).map((a) => a.slug).join(',')}
-  `;
-    const cachedMemo = cache.get('routes');
-    if (cachedMemo && cachedMemo === memo) {
-        return false;
-    }
-    cache.set('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/generate/runtime/index.server.d.ts

@@ -1,44 +0,0 @@
-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-manifest` (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/generate/runtime/index.server.js

@@ -1,92 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { OUTPUT_DIR } from '../../constants.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-manifest` (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/generate/runtime/parse-exports.server.d.ts

@@ -1,7 +0,0 @@
-/**
- * Top-level named + default export identifiers of a module — used by the Vite plugin's
- * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
- * collection's server-only hook, requested by a client build), matching the real side's
- * export names so ESM's static named-export binding doesn't throw at link time.
- */
-export declare function parseExportNames(filePath: string): string[];

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

@@ -1,40 +0,0 @@
-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 — used by the Vite plugin's
- * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
- * collection's server-only hook, requested by a client build), matching the real side's
- * export names so ESM's static named-export binding doesn't throw at link time.
- */
-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)) {
-            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 ('id' in node.declaration &&
-                    node.declaration.id &&
-                    t.isIdentifier(node.declaration.id)) {
-                    names.push(node.declaration.id.name);
-                }
-            }
-            for (const spec of node.specifiers) {
-                if (t.isExportSpecifier(spec) && t.isIdentifier(spec.exported)) {
-                    names.push(spec.exported.name);
-                }
-            }
-        }
-        if (t.isExportDefaultDeclaration(node)) {
-            names.push('default');
-        }
-    }
-    return names;
-}