rimecms 0.33.0 → 1.0.1

package/dist/core/dev/cli/util/package.server.js

@@ -15,3 +15,46 @@ export function getPackageInfoByKey(key) {
         return '';
     }
 }
+const BUN_PREFIX = 'bun --bun ';
+/** Below it, JavaScriptCore's slow lookbehind regexes (Vite's wasm filters) double dev boot. */
+export const MIN_BUN = '1.4';
+const VITE_SCRIPTS = ['dev', 'build', 'preview'];
+function readPackageJson() {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+    // Keep the file's own indentation (sv writes tabs)
+    const indent = raw.match(/^[ \t]+/m)?.[0] ?? '  ';
+    return { path: packageJsonPath, json: JSON.parse(raw), indent };
+}
+/**
+ * Prefixes the app's vite scripts with `bun --bun`, so vite (and `bun:sqlite`) run on Bun
+ * rather than on the Node its bin's shebang asks for. Returns whether it wrote anything.
+ */
+export function setBunScripts() {
+    const { path: packageJsonPath, json, indent } = readPackageJson();
+    let changed = false;
+    for (const key of VITE_SCRIPTS) {
+        const script = json.scripts?.[key];
+        if (typeof script === 'string' && script.startsWith('vite ')) {
+            json.scripts[key] = BUN_PREFIX + script;
+            changed = true;
+        }
+    }
+    if (!json.engines?.bun) {
+        json.engines = { ...json.engines, bun: `>=${MIN_BUN}` };
+        changed = true;
+    }
+    if (changed)
+        fs.writeFileSync(packageJsonPath, JSON.stringify(json, null, indent) + '\n');
+    return changed;
+}
+/** Whether `rime init --bun` set this app up — its vite scripts are what `rime build` reads back. */
+export function usesBunScripts() {
+    try {
+        const { json } = readPackageJson();
+        return VITE_SCRIPTS.some((key) => json.scripts?.[key]?.startsWith(BUN_PREFIX));
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -33,3 +33,5 @@ declare const paramMatcher: (slugs: string[]) => string;
 declare const customRoute: (config: any) => string;
 export declare const commonRoutes: Routes;
 export { customRoute, paramMatcher, prototypeApiServer };
+/** Every fixed route file as the templates write it: a template that changes regenerates them. */
+export declare const templatesSurface: () => string;

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

@@ -90,7 +90,7 @@ export const load = async ({ locals }: ServerLoadEvent) => {
  */
 const signInPage = () => `
 <script>
-  import { SignIn } from '${PACKAGE_NAME}/panel';
+  import { SignIn } from '${PACKAGE_NAME}/panel/public';
   const { data } = $props();
 </script>
 
@@ -113,7 +113,7 @@ export const actions = {
  */
 const forgotPasswordPage = () => `
 <script>
-  import { ForgotPassword } from '${PACKAGE_NAME}/panel'
+  import { ForgotPassword } from '${PACKAGE_NAME}/panel/public'
   const { data } = $props();
 </script>
 <ForgotPassword {data} />`;
@@ -132,7 +132,7 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.f
  */
 const resetPasswordPage = () => `
 <script>
-  import { ResetPassword } from '${PACKAGE_NAME}/panel';
+  import { ResetPassword } from '${PACKAGE_NAME}/panel/public';
   const { data } = $props();
 </script>
 
@@ -435,3 +435,7 @@ export const commonRoutes = {
     }
 };
 export { customRoute, paramMatcher, prototypeApiServer };
+/** Every fixed route file as the templates write it: a template that changes regenerates them. */
+export const templatesSurface = () => Object.entries(commonRoutes)
+    .flatMap(([pattern, files]) => Object.entries(files).map(([type, render]) => `${pattern}/${type}:${render()}`))
+    .join('\n');

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

@@ -16,7 +16,8 @@ export type Routes = Record<string, RouteDefinition>;
  * 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
+ * templates       the fixed files as the package's templates write them today
+ * version         the package the templates ship with
  * ```
  *
  * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes

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

@@ -6,6 +6,7 @@ import { PANEL_ROUTE } from '../../../routes/constants.server.js';
 import { slugify } from '../../../../util/string.js';
 import fs from 'fs';
 import path from 'path';
+import { templatesSurface } from './common.server.js';
 /**
  * Whether the generated route tree still matches what the config and the package would produce.
  *
@@ -17,7 +18,8 @@ import path from '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
+ * templates       the fixed files as the package's templates write them today
+ * version         the package the templates ship with
  * ```
  *
  * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes
@@ -39,6 +41,7 @@ export function shouldRegenerateRoutes(config) {
         .map((p) => `${p.type}:${p.slug}`)
         .join(',')}
     rest:${restSurface()}
+    templates:${templatesSurface()}
     version:${rimeVersion()}
   `;
     if (cache.matches('routes', memo))

package/dist/core/dev/codegen/types/contributions.server.d.ts

@@ -3,8 +3,9 @@ import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
 /**
  * What each config's generated doc type gains beyond its own fields.
  *
- * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
- * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * Three contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with,
+ * `url` adds the address.
  * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
  * a field has to survive both.
  *

package/dist/core/dev/codegen/types/contributions.server.js

@@ -2,11 +2,14 @@ import { isVersioned } from '../../../prototype/shared/versions/enabled.js';
 import { versionsDocType } from '../../../prototype/shared/versions/doc-type.js';
 import { isUpload } from '../../../prototype/collection/upload/enabled.js';
 import { uploadDocType } from '../../../prototype/collection/upload/doc-type.js';
+import { hasUrl } from '../../../prototype/shared/url/enabled.js';
+import { urlDocType } from '../../../prototype/shared/url/doc-type.js';
 /**
  * What each config's generated doc type gains beyond its own fields.
  *
- * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
- * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * Three contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with,
+ * `url` adds the address.
  * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
  * a field has to survive both.
  *
@@ -14,7 +17,11 @@ import { uploadDocType } from '../../../prototype/collection/upload/doc-type.js'
 export const contributionsFor = (config) => 
 // Upload before versions: the prototype's feature list has upload first, and the members land
 // in that order in the generated type.
-[isUpload(config) ? uploadDocType(config) : null, isVersioned(config) ? versionsDocType() : null]
+[
+    isUpload(config) ? uploadDocType(config) : null,
+    isVersioned(config) ? versionsDocType() : null,
+    hasUrl(config) ? urlDocType(config.type) : null
+]
     .filter((c) => c !== null)
     .reduce((current, contribution) => ({
     extends: [...current.extends, ...(contribution.extends ?? [])],

package/dist/core/dev/config-memo.server.js

@@ -2,6 +2,7 @@ import { flatten } from 'flat';
 import cache from './cache.server.js';
 import { CONFIG_DIR } from './constants.server.js';
 import { restSurface } from './prototype-routes.server.js';
+import { templatesSurface } from './codegen/routes/common.server.js';
 import { rimeVersion } from './version.server.js';
 /**
  * We actually need to serialize config values that will trigger
@@ -76,6 +77,9 @@ const writeMemo = (config) => {
         // `generateRoutes` included, so a route added to a prototype has to move it — a version bump
         // does not, inside this repo, and the config never mentions those paths at all.
         .concat(`REST_SURFACE:${restSurface()}`)
+        // Nor are the route templates, which change inside this repo and between two packs of one
+        // version: the routes they write must follow.
+        .concat(`ROUTE_TEMPLATES:${templatesSurface()}`)
         .join('\n');
     if (cache.matches('config', memoStr))
         return false;

package/dist/core/dev/vite.server.js

@@ -149,16 +149,17 @@ export function rime() {
         },
         config() {
             return {
+                // `bun:sqlite` only exists at runtime under Bun (adapterSqlite driver 'bun').
                 ssr: {
-                    external: ['sharp']
+                    external: ['sharp', 'bun:sqlite']
                 },
                 optimizeDeps: {
-                    exclude: ['sharp'],
+                    exclude: ['sharp', 'bun:sqlite'],
                     include: ['@lucide/svelte']
                 },
                 build: {
                     rollupOptions: {
-                        external: ['sharp']
+                        external: ['sharp', 'bun:sqlite']
                     },
                     target: 'es2022'
                 },

package/dist/core/fields/blank.d.ts

@@ -0,0 +1,21 @@
+import type { FieldBuilder } from './builders/field-builder.js';
+import type { Field } from '../../fields/types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/** What a field is handed to build its blank value. The event is a default's, and boot has none. */
+export type BlankContext = {
+    event?: RequestEvent;
+};
+/**
+ * A list of fields as a blank object, each field contributing its own members.
+ *
+ * A branch opens an object, a leaf holds its default, and a repeater holds its own — `#` in a
+ * segment means only a document can name the children.
+ *
+ * ```
+ * group('attributes').fields(text('title'))   ->  { attributes: { title: null } }
+ * tabs(tab('meta').fields(text('title')))     ->  { meta: { title: null } }
+ * blocks('layout', [...])                     ->  { layout: [] }
+ * ```
+ */
+export declare const blankFields: (fields: FieldBuilder<Field>[], context?: BlankContext) => Dic;

package/dist/core/fields/blank.js

@@ -0,0 +1,37 @@
+import { isFormField } from './util.js';
+/**
+ * A list of fields as a blank object, each field contributing its own members.
+ *
+ * A branch opens an object, a leaf holds its default, and a repeater holds its own — `#` in a
+ * segment means only a document can name the children.
+ *
+ * ```
+ * group('attributes').fields(text('title'))   ->  { attributes: { title: null } }
+ * tabs(tab('meta').fields(text('title')))     ->  { meta: { title: null } }
+ * blocks('layout', [...])                     ->  { layout: [] }
+ * ```
+ */
+export const blankFields = (fields, context = {}) => {
+    const doc = {};
+    for (const field of fields) {
+        try {
+            const nodes = field.use.nodes();
+            if (!nodes.length || nodes.some((node) => node.segment.includes('#'))) {
+                if (isFormField(field))
+                    doc[field.name] = field.use.defaultValue(context) ?? null;
+                continue;
+            }
+            // Its name opens an object, or it has none and its branches land on this one.
+            const target = field.name ? (doc[field.name] = {}) : doc;
+            for (const node of nodes) {
+                const bucket = node.segment ? (target[node.segment] = {}) : target;
+                Object.assign(bucket, blankFields(node.fields, context));
+            }
+        }
+        catch (err) {
+            console.error(`Building the blank value of ${field.type} field "${field.name}" failed.`);
+            throw err;
+        }
+    }
+    return doc;
+};

package/dist/core/fields/builders/field-builder.d.ts

@@ -23,6 +23,53 @@ export type FieldUse = {
     accessCreate(...args: Parameters<FieldAccess>): boolean;
     accessUpdate(...args: Parameters<FieldAccess>): boolean;
     generateType(): string;
+    /** Every branch this field can produce, from the config alone. */
+    nodes(): FieldNode[];
+    /** The branches this particular value has. */
+    nodesFor(value: unknown): ValueNode[];
+};
+/**
+ * One branch below a field: what it adds to the path, and the fields under it.
+ *
+ * ```
+ * group('attributes')  ->  { segment: '',        fields: [ text('title') ] }
+ * tabs(tab('meta'))    ->  { segment: 'meta',    fields: [ text('title') ] }
+ * blocks('layout')     ->  { segment: '#:hero',  fields: [ text('title') ] }
+ * tree('nav')          ->  { segment: '#', repeatVia: '_children', fields: [ text('label') ] }
+ * ```
+ */
+export type FieldNode = {
+    /**
+     * The segment this branch contributes below the field's own name. `''` when it contributes
+     * nothing — Group, whose own name is already the segment. `#` stands for an index that only a
+     * document can supply.
+     */
+    segment: string;
+    /**
+     * When set, the branch nests into itself through this segment, so `nav.0`, `nav.0._children.1`
+     * and deeper are all this same branch. Read when resolving a path; a value walk flattens the
+     * recursion itself.
+     */
+    repeatVia?: string;
+    fields: FieldBuilder[];
+    /**
+     * The branch is stored as rows of its own, in a child table of the owner, not as its columns.
+     * `kind` is the table's marker on disk; `name` is what follows it.
+     *
+     * ```
+     * blocks('layout', [block('hero')])   { kind: 'blocks', name: 'hero' }    pages__$blocks_hero
+     * tree('nav')                         { kind: 'tree', name: 'nav' }       pages__$tree_nav
+     * ```
+     */
+    storage?: NodeStorage;
+};
+export type NodeStorage = {
+    kind: 'blocks' | 'tree';
+    name: string;
+};
+/** A branch a real value has: a concrete segment, no `#`, and the data under it. */
+export type ValueNode = FieldNode & {
+    value: unknown;
 };
 export declare class FieldBuilder<T extends Field = Field> {
     field: T;
@@ -68,4 +115,10 @@ export declare class FieldBuilder<T extends Field = Field> {
      *  compile error), while staying a real overridable method so every concrete field can
      *  provide its own, unlike a private `#field` which can't be polymorphically overridden. */
     protected generateType(): string;
+    /** The branches below this field, from the config alone. A leaf has none.
+     *  `protected` and reached through `.use.nodes()`, same as `generateType`. */
+    protected nodes(): FieldNode[];
+    /** The branches below this field for one value. A leaf has none.
+     *  `protected` and reached through `.use.nodesFor()`, same as `generateType`. */
+    protected nodesFor(_value: unknown): ValueNode[];
 }

package/dist/core/fields/builders/field-builder.js

@@ -56,7 +56,9 @@ export class FieldBuilder {
             accessCreate: (..._args) => true,
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             accessUpdate: (..._args) => true,
-            generateType: () => this.generateType()
+            generateType: () => this.generateType(),
+            nodes: () => this.nodes(),
+            nodesFor: (value) => this.nodesFor(value)
         };
     }
     get component() {
@@ -72,4 +74,15 @@ export class FieldBuilder {
     generateType() {
         return '';
     }
+    /** The branches below this field, from the config alone. A leaf has none.
+     *  `protected` and reached through `.use.nodes()`, same as `generateType`. */
+    nodes() {
+        return [];
+    }
+    /** The branches below this field for one value. A leaf has none.
+     *  `protected` and reached through `.use.nodesFor()`, same as `generateType`. */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    nodesFor(_value) {
+        return [];
+    }
 }

package/dist/core/fields/builders/form-field-builder.d.ts

@@ -67,6 +67,14 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
      * `_parent` on a nested collection is the typical case: the site tree must not fork per version.
      */
     $root(): this;
+    /**
+     * Indexes the field's column, for a field a list is filtered or sorted by.
+     *
+     * ```ts
+     * text('sku').$index()   // where[sku][equals]=… reads the index, not every row
+     * ```
+     */
+    $index(): this;
     /** `label`/`localized`/`root`/`required` are the only properties that need
      *  anything beyond a plain `this.field` read (a fallback default, or a
      *  boolean coercion) — everything else a concrete field type adds

package/dist/core/fields/builders/form-field-builder.js

@@ -69,6 +69,17 @@ export class FormFieldBuilder extends FieldBuilder {
         this.field.root = true;
         return this;
     }
+    /**
+     * Indexes the field's column, for a field a list is filtered or sorted by.
+     *
+     * ```ts
+     * text('sku').$index()   // where[sku][equals]=… reads the index, not every row
+     * ```
+     */
+    $index() {
+        this.field.index = true;
+        return this;
+    }
     /** `label`/`localized`/`root`/`required` are the only properties that need
      *  anything beyond a plain `this.field` read (a fallback default, or a
      *  boolean coercion) — everything else a concrete field type adds
@@ -148,7 +159,9 @@ export class FormFieldBuilder extends FieldBuilder {
                 const value = this.field.defaultValue;
                 return typeof value === 'function' ? value(context) : value;
             },
-            generateType: () => this._references?.resolve ? this.resolvedReferenceType() : this.generateType()
+            generateType: () => this._references?.resolve ? this.resolvedReferenceType() : this.generateType(),
+            nodes: () => this.nodes(),
+            nodesFor: (value) => this.nodesFor(value)
         };
     }
     /** The document a resolved reference reads as, whatever the field's own type says. */

package/dist/core/fields/util.d.ts

@@ -1,4 +1,4 @@
-import type { Field, FormField, SeparatorField } from '../../fields/types.js';
+import type { Field, FieldAccess, FormField, SeparatorField } from '../../fields/types.js';
 import type { Dic } from '../../util/types.js';
 import type { FormFieldBuilder } from './builders/form-field-builder.js';
 import type { FieldBuilder } from './builders/index.js';
@@ -35,7 +35,7 @@ export declare const isLiveField: (field: Field) => boolean | undefined;
  *   ]}
  * ]);
  */
-export declare const emptyValuesFromFieldConfig: <T extends FormFieldBuilder>(arr: T[]) => Dic;
+export declare const emptyValuesFromFieldConfig: (fields: FieldBuilder[]) => Dic;
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -85,6 +85,8 @@ export declare const baseFieldNames: (config: {
     fields: FieldBuilder[];
 }) => string[];
 export type ResolvedReference = {
+    /** The field itself, for whoever must ask it something — who may read it, for one. */
+    field: FormFieldBuilder<FormField>;
     /** The document path: `meta.owner`. */
     path: string;
     /** The column it is stored in: `meta__owner`. */
@@ -109,6 +111,11 @@ export type ResolvedReference = {
  * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
  * own tables and are not walked.
  */
+/**
+ * The resolved references a reader may see, by path — what a read asks the adapter to join. A
+ * reference the pipeline would drop for this reader is not joined for nothing.
+ */
+export declare const readableReferences: (fields: FieldBuilder[], user: Parameters<FieldAccess>[0]) => string[];
 export declare const resolvedReferencesOf: (fields: FieldBuilder[], parentPath?: string) => ResolvedReference[];
 /**
  * Splits a write into the half that belongs on the base row and the half that belongs on the