rimecms 0.30.2 → 0.30.3

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

@@ -4,21 +4,27 @@ import path from 'node:path';
 import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 import { ensureHasInit } from '../../ensure.server.js';
 import { logger } from '../../logger/index.server.js';
-import { INPUT_DIR, OUTPUT_DIR } from '../constants.js';
+import { INPUT_DIR, isInstalledDependency, OUTPUT_DIR } from '../constants.js';
+import { buildRuntimeRegistry } from '../generate/runtime/index.server.js';
 import { sanitize } from '../generate/sanitize/index.server.js';
 dotenv.config({ override: true });
 const dev = process.env.NODE_ENV === 'development';
 export function rime() {
     const VCoreId = '$rime/config';
     const VSchemaId = '$rime/schema';
-    /** General-purpose server/browser split, usable anywhere in the app (not just rime's own
-     *  field code — see relation/index.ts for the first user). `import { x } from '$rime/runtime'`
-     *  resolves to a sibling `server.ts` (server builds) or `browser.ts` (browser builds) next
-     *  to whichever file does the importing — the importer's path travels encoded in the
-     *  resolved id since `load()` only receives the id, not the importer. */
-    const VRuntimeId = '$rime/runtime';
-    const VRuntimeMarker = `\0${VRuntimeId}::`;
+    /** Any field's client/server split: rime's own (relation/index.ts, link/index.ts) and a
+     *  consumer app's own local fields alike. `import { x } from '$rime/<name>'` resolves `<name>`
+     *  against a registry built once (see generate/runtime/index.server.ts's buildRuntimeRegistry,
+     *  which scans for `<name>/module.ts` + `module.server.ts` pairs) to either `module.server.ts`
+     *  (server builds) or `module.ts` (browser builds). The specifier is a static string baked into
+     *  the source, so it survives esbuild's dep-optimizer flattening — unlike an importer-relative
+     *  lookup, which breaks the moment the importing file gets pre-bundled (importer becomes the
+     *  flattened chunk, not the real source file). `config` and `schema` are reserved names (see
+     *  VCoreId/VSchemaId below, checked first) — a field can't be registered under either. */
+    const VPrefix = '$rime/';
     const resolvedVModule = (name) => '\0' + name;
+    let runtimeRegistry = null;
+    const getRuntimeRegistry = () => (runtimeRegistry ??= buildRuntimeRegistry());
     return {
         name: 'virtual-rime',
         configureServer(server) {
@@ -66,12 +72,7 @@ export function rime() {
                     external: ['sharp']
                 },
                 optimizeDeps: {
-                    // rimecms/fields and rimecms/panel must not be pre-bundled: esbuild flattens
-                    // their source files into one chunk, which erases the per-file identity that
-                    // the $rime/runtime virtual module (see resolveId/load below) relies on to find
-                    // each field's sibling runtime.ts/runtime.server.ts — pre-bundling makes the
-                    // "importer" resolve to the chunk itself instead of the real source file.
-                    exclude: ['sharp', 'rimecms', 'rimecms/fields', 'rimecms/panel'],
+                    exclude: ['sharp'],
                     include: ['@lucide/svelte']
                 },
                 build: {
@@ -79,6 +80,14 @@ export function rime() {
                         external: ['sharp']
                     },
                     target: 'es2022'
+                },
+                server: {
+                    watch: {
+                        // db/*.sqlite (+ its -wal/-shm sidecars) and logs/ are runtime data, not source —
+                        // every write (e.g. saving a document) touches them, and without this Vite's default
+                        // whole-project-root watch treats that churn as a source change and force-reloads.
+                        ignored: ['**/db/**', '**/logs/**']
+                    }
                 }
             };
         },
@@ -91,22 +100,27 @@ export function rime() {
                 }
                 return null;
             }
-            if (process.env.IS_PACKAGE_DEV && file.includes('src/lib/core/config')) {
+            if (!isInstalledDependency(import.meta.url) && file.includes('src/lib/core/config')) {
                 logger.info('reload core config');
                 const module = invalidateVModule(VCoreId);
                 if (module)
                     return [module];
             }
         },
-        resolveId(id, importer) {
+        resolveId(id) {
             if (id === VCoreId) {
                 return resolvedVModule(id);
             }
             if (id === VSchemaId) {
                 return resolvedVModule(id);
             }
-            if (id === VRuntimeId && importer) {
-                return `${VRuntimeMarker}${importer}`;
+            if (id.startsWith(VPrefix)) {
+                const name = id.slice(VPrefix.length);
+                // Unregistered name: return null so it surfaces as a normal "failed to resolve
+                // import" error instead of a silent virtual-module 404.
+                if (!getRuntimeRegistry().has(name))
+                    return null;
+                return resolvedVModule(id);
             }
             return null;
         },
@@ -123,11 +137,13 @@ export function rime() {
                     return `export * from '${modulePath}'; export { default } from '${modulePath}';`;
                 }
             }
-            if (id.startsWith(VRuntimeMarker)) {
-                const importer = id.slice(VRuntimeMarker.length);
-                const dir = path.dirname(importer);
-                const target = path.join(dir, isServer ? 'runtime.server.ts' : 'runtime.ts');
-                return `export * from '${target.replace(/\.ts$/, '.js')}';`;
+            if (id.startsWith(resolvedVModule(VPrefix))) {
+                const name = id.slice(resolvedVModule(VPrefix).length);
+                const entry = getRuntimeRegistry().get(name);
+                if (entry) {
+                    const target = (isServer ? entry.server : entry.client).replace(/\.ts$/, '.js');
+                    return `export * from '${target}';`;
+                }
             }
             return null;
         }

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

@@ -1,5 +1,4 @@
 import type { DefaultValueFn, FieldValidationFunc, FormField } from '../../../fields/types.js';
-import type { DataType } from './form-field-builder.js';
 import { FormFieldBuilder } from './form-field-builder.js';
 type BooleanField = FormField & {
     type: any;
@@ -10,7 +9,7 @@ type BooleanField = FormField & {
 export declare class BooleanFieldBuilder<T extends BooleanField = BooleanField> extends FormFieldBuilder<T> {
     constructor(name: string, type: string);
     defaultValue(value: boolean | DefaultValueFn<boolean>): this;
-    get dataType(): DataType;
+    get dataType(): 'boolean';
     compile(): import("../../../util/types.js").WithoutBuilders<T> & {
         component: import("svelte").Component<any>;
         cell?: import("svelte").Component<{

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

@@ -7,14 +7,14 @@ import type { Field, FieldAccess } from '../../../fields/types.js';
  *  generically-typed prop — stay bivariant on their params, exactly like the
  *  class methods this replaced. Property syntax would make TS check those
  *  params strictly/contravariantly and break that assignability. */
-export type FieldRun = {
-    canRead(...args: Parameters<FieldAccess>): boolean;
-    canCreate(...args: Parameters<FieldAccess>): boolean;
-    canUpdate(...args: Parameters<FieldAccess>): boolean;
+export type FieldUse = {
+    accessRead(...args: Parameters<FieldAccess>): boolean;
+    accessCreate(...args: Parameters<FieldAccess>): boolean;
+    accessUpdate(...args: Parameters<FieldAccess>): boolean;
+    generateType(): string;
 };
 export declare class FieldBuilder<T extends Field = Field> {
     field: T;
-    _metaUrl?: string;
     constructor(type: string);
     get name(): string;
     className(str: string): this;
@@ -47,9 +47,14 @@ export declare class FieldBuilder<T extends Field = Field> {
      *  (`T extends FieldBuilder<any>`) strictly, not with the bivariant
      *  leniency normal overrides get, so a param-less base signature breaks
      *  assignability everywhere. */
-    get run(): FieldRun;
+    get use(): FieldUse;
     get component(): Component<any> | null;
     get cell(): Component<{
         value: any;
     }> | null;
+    /** The type-generation script's only entry point (via `.use.generateType()`) — `protected`
+     *  so it never surfaces on the fluent chain (`text('title').generateType()` would be a
+     *  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;
 }

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

@@ -1,6 +1,5 @@
 export class FieldBuilder {
     field;
-    _metaUrl;
     constructor(type) {
         this.field = {
             name: '',
@@ -49,14 +48,15 @@ export class FieldBuilder {
      *  (`T extends FieldBuilder<any>`) strictly, not with the bivariant
      *  leniency normal overrides get, so a param-less base signature breaks
      *  assignability everywhere. */
-    get run() {
+    get use() {
         return {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            canRead: (..._args) => true,
+            accessRead: (..._args) => true,
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            canCreate: (..._args) => true,
+            accessCreate: (..._args) => true,
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            canUpdate: (..._args) => true
+            accessUpdate: (..._args) => true,
+            generateType: () => this.generateType()
         };
     }
     get component() {
@@ -65,4 +65,11 @@ export class FieldBuilder {
     get cell() {
         return null;
     }
+    /** The type-generation script's only entry point (via `.use.generateType()`) — `protected`
+     *  so it never surfaces on the fluent chain (`text('title').generateType()` would be a
+     *  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. */
+    generateType() {
+        return '';
+    }
 }

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

@@ -2,16 +2,16 @@ import type { FieldPanelTableConfig } from '../../../types.js';
 import type { Dic } from '../../../util/types.js';
 import type { RequestEvent } from '@sveltejs/kit';
 import type { FieldAccess, FieldHook, FieldHookClient, FieldHookContext, FieldHookShared, FieldValidationFunc, FieldWidth, FormField } from '../../../fields/types.js';
-import { FieldBuilder, type FieldRun } from './field-builder.js';
+import { FieldBuilder, type FieldUse } from './field-builder.js';
 /** Adapter-agnostic storage primitive — column syntax only, not default-value semantics. */
 export type DataType = 'text' | 'boolean' | 'number' | 'timestamp' | 'json';
-/** Method-syntax, same reasoning as `FieldRun` — keeps `run`'s params
+/** Method-syntax, same reasoning as `FieldUse` — keeps `run`'s params
  *  bivariant across concrete field types so e.g. `SlugFieldBuilder` still
  *  satisfies a prop typed `FormFieldBuilder<FormField>`. */
-export type FormFieldRun<T extends FormField> = FieldRun & {
+export type FormFieldUse<T extends FormField> = FieldUse & {
     isEmpty(value: unknown): boolean;
     validate(value: unknown, context: Parameters<FieldValidationFunc<T>>[1]): true | string;
-    condition(doc: Dic, siblings: Dic): boolean;
+    isVisible(doc: Dic, siblings: Dic): boolean;
     onChange(value: unknown, context: Parameters<FieldHookClient>[1]): void;
     beforeRead(value: unknown, context: Omit<FieldHookContext<T>, 'config'>): Promise<any>;
     beforeSave(value: unknown, context: FieldHookContext<T>): Promise<any>;
@@ -38,15 +38,9 @@ export type FieldReference = FieldReferenceOptions & {
     table: string;
 };
 export declare class FormFieldBuilder<T extends FormField = FormField> extends FieldBuilder<T> {
-    /** Every concrete leaf field builder is expected to implement a
-     *  `get dataType(): DataType` accessor (see e.g. `$lib/fields/text/index.ts`).
-     *  Not declared here — TS doesn't allow `declare` on accessors in this
-     *  project's config, and a plain base field would conflict with subclasses
-     *  that need a computed getter (e.g. `select`, whose dataType depends on
-     *  `many`). Container builders (Group/Tabs/Blocks/Tree) never get asked,
-     *  since the adapter's tree-walker special-cases them before reaching the
-     *  generic column-rendering branch; `column.server.ts` reads `.dataType`
-     *  via a narrow cast for the same reason it already casts `unique`. */
+    /** Column storage type, used to generate the DB schema. Every field
+     *  builder that stores data must define its own. */
+    get dataType(): DataType;
     _references: FieldReference | null;
     constructor(name: string, type: string);
     label(label: string): this;
@@ -83,7 +77,7 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
     onChange(hook: FieldHookClient): this;
     /** Behavior the builder runs on your behalf — invoking a stored function or
      *  hook list, not a data read (see `.get` for that). */
-    get run(): FormFieldRun<T>;
+    get use(): FormFieldUse<T>;
     hint(hint: string): this;
     clone(): typeof this;
     /** Server-side schema concern, same family as $beforeRead/$beforeSave. */
@@ -91,4 +85,7 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
     $beforeRead(hook: FieldHook<T>): this;
     $beforeSave(hook: FieldHook<T>): this;
     beforeValidate(hook: FieldHookShared): this;
+    /** Fallback for a data-bearing field that doesn't override this: still shows up in the
+     *  generated document type (as `any`) instead of silently vanishing from it. */
+    protected generateType(): string;
 }

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

@@ -2,15 +2,11 @@ import { capitalize } from '../../../util/string.js';
 import cloneDeep from 'clone-deep';
 import { FieldBuilder } from './field-builder.js';
 export class FormFieldBuilder extends FieldBuilder {
-    /** Every concrete leaf field builder is expected to implement a
-     *  `get dataType(): DataType` accessor (see e.g. `$lib/fields/text/index.ts`).
-     *  Not declared here — TS doesn't allow `declare` on accessors in this
-     *  project's config, and a plain base field would conflict with subclasses
-     *  that need a computed getter (e.g. `select`, whose dataType depends on
-     *  `many`). Container builders (Group/Tabs/Blocks/Tree) never get asked,
-     *  since the adapter's tree-walker special-cases them before reaching the
-     *  generic column-rendering branch; `column.server.ts` reads `.dataType`
-     *  via a narrow cast for the same reason it already casts `unique`. */
+    /** Column storage type, used to generate the DB schema. Every field
+     *  builder that stores data must define its own. */
+    get dataType() {
+        throw new Error(`${this.constructor.name} does not implement dataType`);
+    }
     _references = null;
     constructor(name, type) {
         super(type);
@@ -100,7 +96,7 @@ export class FormFieldBuilder extends FieldBuilder {
     }
     /** Behavior the builder runs on your behalf — invoking a stored function or
      *  hook list, not a data read (see `.get` for that). */
-    get run() {
+    get use() {
         return {
             isEmpty: (value) => this.field.isEmpty(value),
             validate: (value, context) => {
@@ -109,7 +105,7 @@ export class FormFieldBuilder extends FieldBuilder {
                 }
                 return true;
             },
-            condition: (doc, siblings) => {
+            isVisible: (doc, siblings) => {
                 if (this.field.condition) {
                     try {
                         return this.field.condition(doc, siblings);
@@ -121,9 +117,9 @@ export class FormFieldBuilder extends FieldBuilder {
                 }
                 return true;
             },
-            canRead: (...args) => !!this.field.access?.read?.(...args),
-            canCreate: (...args) => !!this.field.access?.create?.(...args),
-            canUpdate: (...args) => !!this.field.access?.update?.(...args),
+            accessRead: (...args) => !!this.field.access?.read?.(...args),
+            accessCreate: (...args) => !!this.field.access?.create?.(...args),
+            accessUpdate: (...args) => !!this.field.access?.update?.(...args),
             onChange: (value, context) => {
                 for (const hook of this.field.hooks?.onChange ?? []) {
                     hook(value, context);
@@ -153,7 +149,8 @@ export class FormFieldBuilder extends FieldBuilder {
             defaultValue: (context = {}) => {
                 const value = this.field.defaultValue;
                 return typeof value === 'function' ? value(context) : value;
-            }
+            },
+            generateType: () => this.generateType()
         };
     }
     hint(hint) {
@@ -192,4 +189,9 @@ export class FormFieldBuilder extends FieldBuilder {
         this.field.hooks.beforeValidate.push(hook);
         return this;
     }
+    /** Fallback for a data-bearing field that doesn't override this: still shows up in the
+     *  generated document type (as `any`) instead of silently vanishing from it. */
+    generateType() {
+        return `${this.field.name}${this.get.required ? '' : '?'}: any`;
+    }
 }

package/dist/core/fields/util.js

@@ -56,7 +56,7 @@ export const emptyValuesFromFieldConfig = (arr) => {
         }
         // Handle default values
         else {
-            emptyValue = config.run.defaultValue();
+            emptyValue = config.use.defaultValue();
         }
         return [config.name, emptyValue];
     }));

package/dist/core/operations/blocks/extract.server.js

@@ -5,7 +5,7 @@ export function extractBlocks({ data, configMap }) {
     Object.entries(configMap).forEach(([path, config]) => {
         if (config.type === 'blocks') {
             const value = getValueAtPath(path, data);
-            const isEmptyValue = config.run.isEmpty(value);
+            const isEmptyValue = config.use.isEmpty(value);
             if (value && !isEmptyValue) {
                 value.forEach((block, index) => {
                     if (block.type) {

package/dist/core/operations/hooks/before-read/process-document-fields.server.js

@@ -10,12 +10,12 @@ export const processDocumentFields = Hooks.beforeRead(async (args) => {
     for (const [key, config] of Object.entries(configMap)) {
         let value = getValueAtPath(key, doc);
         let isEmpty;
-        if (!config.run.canRead(event.locals.user)) {
+        if (!config.use.accessRead(event.locals.user)) {
             doc = deleteValueAtPath(doc, key);
             continue;
         }
         if (value !== undefined && value !== null) {
-            value = await config.run.beforeRead(value, {
+            value = await config.use.beforeRead(value, {
                 event,
                 operation: args.context,
                 documentId: doc.id
@@ -23,7 +23,7 @@ export const processDocumentFields = Hooks.beforeRead(async (args) => {
             doc = setValueAtPath(key, doc, value);
         }
         try {
-            isEmpty = config.run.isEmpty(value);
+            isEmpty = config.use.isEmpty(value);
         }
         catch {
             isEmpty = false;

package/dist/core/operations/hooks/before-upsert/set-default-values.server.js

@@ -17,7 +17,7 @@ export const setDefaultValues = Hooks.beforeUpsert(async (args) => {
         let isEmpty;
         const shouldAddDefault = operation === 'create' || (operation === 'update' && config.get.required);
         try {
-            isEmpty = config.run.isEmpty(value);
+            isEmpty = config.use.isEmpty(value);
         }
         catch {
             isEmpty = false;
@@ -60,11 +60,11 @@ const defaultRelationValue = async (config, key, adapter) => {
             documentId: documentId
         }));
     };
-    return await buildRelation(config.run.defaultValue({ event: getRequestEvent() }));
+    return await buildRelation(config.use.defaultValue({ event: getRequestEvent() }));
 };
 export const getDefaultValue = async ({ key, config, adapter }) => {
     if (config instanceof RelationFieldBuilder) {
         return await defaultRelationValue(config, key, adapter);
     }
-    return config.run.defaultValue({ event: getRequestEvent() });
+    return config.use.defaultValue({ event: getRequestEvent() });
 };

package/dist/core/operations/hooks/before-upsert/validate-fields.server.js

@@ -63,7 +63,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /* Field hook before validate
         /****************************************************/
         if (value !== undefined && value !== null && !skipHooks) {
-            value = await config.run.beforeValidate(value, { config, data: args.data });
+            value = await config.use.beforeValidate(value, { config, data: args.data });
             output = setValueAtPath(key, output, value);
         }
         /****************************************************/
@@ -71,7 +71,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /****************************************************/
         if (config.get.validate && value !== undefined && value !== null && !skipHooks) {
             try {
-                const valid = config.run.validate(value, {
+                const valid = config.use.validate(value, {
                     data: output,
                     operation,
                     id: operation === 'update' ? args.context.originalDoc?.id : undefined,
@@ -93,7 +93,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /* Field hook before Save
         */
         if (value !== undefined && value !== null && !skipHooks) {
-            value = await config.run.beforeSave(value, {
+            value = await config.use.beforeSave(value, {
                 config: config.get,
                 event,
                 operation: args.context
@@ -104,7 +104,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /* Access
         /****************************************************/
         if (operation === 'update' && !skipAccess) {
-            const authorizedFieldUpdate = config.run.canUpdate(user, {
+            const authorizedFieldUpdate = config.use.accessUpdate(user, {
                 id: args.context.originalDoc?.id
             });
             if (!authorizedFieldUpdate) {
@@ -114,7 +114,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
             }
         }
         if (operation === 'create' && !skipAccess) {
-            const authorizedFieldCreate = config.run.canCreate(user, {
+            const authorizedFieldCreate = config.use.accessCreate(user, {
                 id: undefined
             });
             if (!authorizedFieldCreate) {
@@ -124,12 +124,12 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
             }
         }
         // Required
-        if (config.get.required && config.run.isEmpty(value)) {
+        if (config.get.required && config.use.isEmpty(value)) {
             if (skipRequired) {
                 // The field's own type-correct default (falling back to '' only
                 // when none is set) — a hardcoded '' here was wrong for every
                 // non-string required field (number, checkbox, date, ...).
-                output = setValueAtPath(key, output, config.run.defaultValue({ event }) ?? '');
+                output = setValueAtPath(key, output, config.use.defaultValue({ event }) ?? '');
             }
             else {
                 errors[key] = RimeFormError.REQUIRED_FIELD;

package/dist/core/operations/shared/fallback-data-from-original.js

@@ -16,7 +16,7 @@ export const fallbackDataFromOriginal = async (args) => {
         let value = getValueAtPath(key, output);
         let isEmpty;
         try {
-            isEmpty = config.run.isEmpty(value);
+            isEmpty = config.use.isEmpty(value);
         }
         catch {
             isEmpty = false;

package/dist/core/operations/tree/extract.server.js

@@ -22,7 +22,7 @@ export function extractTreeBlocks({ data, configMap }) {
     Object.entries(configMap).forEach(([path, config]) => {
         if (config.type === 'tree') {
             const value = getValueAtPath(path, data);
-            const isEmptyValue = config.run.isEmpty(value);
+            const isEmptyValue = config.use.isEmpty(value);
             if (value && !isEmptyValue) {
                 value.forEach((item, index) => {
                     processTreeItem(item, index, path, undefined);

package/dist/core/plugins/api-init/index.server.js

@@ -28,7 +28,7 @@ export const apiInit = definePlugin(() => {
             });
         }
         event.locals.isInit = true;
-        const [signUpError] = await trycatch(() => event.locals.rime.auth.api.signUpEmail({
+        const [signUpError, response] = await trycatch(() => event.locals.rime.auth.api.signUpEmail({
             body: {
                 email: data.email,
                 name: data.name,
@@ -42,7 +42,7 @@ export const apiInit = definePlugin(() => {
                 formData: { email: data.email }
             });
         }
-        return json({ initialized: true });
+        return json({ initialized: true, user: response.user });
     };
     return {
         name: 'apiInit',

package/dist/fields/blocks/index.d.ts

@@ -7,7 +7,6 @@ import type { Component } from 'svelte';
 export declare const blocks: (name: string, blocks: BlockBuilder[]) => BlocksBuilder;
 export declare const block: (name: string) => BlockBuilder;
 export declare class BlocksBuilder extends FormFieldBuilder<BlocksField> {
-    _metaUrl: string;
     constructor(name: string, blocks: BlockBuilder[]);
     get component(): Component<import("./component/props.js").BlocksProps, {}, "">;
     get cell(): Component<{
@@ -17,6 +16,7 @@ export declare class BlocksBuilder extends FormFieldBuilder<BlocksField> {
     }, {}, "">;
     localized(): this;
     compile(): any;
+    protected generateType(): string;
 }
 /**
  * Checks if a field is a blocks field.

package/dist/fields/blocks/index.js

@@ -1,4 +1,5 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import { toPascalCase } from '../../util/string.js';
 import { number } from '../number/index.js';
 import { text } from '../text/index.js';
 import Blocks from './component/Blocks.svelte';
@@ -6,8 +7,6 @@ import Cell from './component/Cell.svelte';
 export const blocks = (name, blocks) => new BlocksBuilder(name, blocks);
 export const block = (name) => new BlockBuilder(name);
 export class BlocksBuilder extends FormFieldBuilder {
-    //
-    _metaUrl = import.meta.url;
     constructor(name, blocks) {
         super(name, 'blocks');
         this.field.blocks = blocks;
@@ -67,6 +66,10 @@ export class BlocksBuilder extends FormFieldBuilder {
             cell: this.cell || undefined
         };
     }
+    generateType() {
+        const blockNames = this.field.blocks.map((block) => `Block${toPascalCase(block.name)}`);
+        return `${this.name}: Array<${blockNames.join(' | ')}>,`;
+    }
 }
 /**
  * Checks if a field is a blocks field.

package/dist/fields/checkbox/index.d.ts

@@ -1,8 +1,8 @@
 import type { FormField } from '../types.js';
 import { BooleanFieldBuilder } from '../../core/fields/builders/boolean-builder.js';
 export declare class CheckboxFieldBuilder extends BooleanFieldBuilder<CheckboxField> {
-    _metaUrl: string;
     get component(): import("svelte").Component<import("./component/props.js").CheckboxProps, {}, "">;
+    protected generateType(): string;
 }
 export declare const checkbox: (name: string) => CheckboxFieldBuilder;
 /****************************************************/

package/dist/fields/checkbox/index.js

@@ -1,10 +1,11 @@
 import { BooleanFieldBuilder } from '../../core/fields/builders/boolean-builder.js';
 import Checkbox from './component/Checkbox.svelte';
 export class CheckboxFieldBuilder extends BooleanFieldBuilder {
-    //
-    _metaUrl = import.meta.url;
     get component() {
         return Checkbox;
     }
+    generateType() {
+        return `${this.name}: boolean`;
+    }
 }
 export const checkbox = (name) => new CheckboxFieldBuilder(name, 'checkbox');

package/dist/fields/combobox/index.d.ts

@@ -1,10 +1,10 @@
 import type { DefaultValueFn, FormField, OptionWithIcon } from '../types.js';
 import { PickOneFieldBuilder } from '../../core/fields/builders/select-builder.js';
 export declare class ComboBoxFieldBuilder extends PickOneFieldBuilder<ComboBoxField> {
-    _metaUrl: string;
     get component(): import("svelte").Component<import("./component/props.js").ComboBoxProps, {}, "">;
     options(...options: OptionWithIcon[] | string[]): this;
     defaultValue(value: string | DefaultValueFn<string>): this;
+    protected generateType(): string;
 }
 export declare const combobox: (name: string) => ComboBoxFieldBuilder;
 /****************************************************/

package/dist/fields/combobox/index.js

@@ -1,8 +1,6 @@
 import { PickOneFieldBuilder } from '../../core/fields/builders/select-builder.js';
 import Combobox from './component/ComboBox.svelte';
 export class ComboBoxFieldBuilder extends PickOneFieldBuilder {
-    //
-    _metaUrl = import.meta.url;
     get component() {
         return Combobox;
     }
@@ -13,5 +11,9 @@ export class ComboBoxFieldBuilder extends PickOneFieldBuilder {
         this.field.defaultValue = value;
         return this;
     }
+    generateType() {
+        const optionsJoinedType = this.get.options.map((o) => `'${o.value}'`).join(' | ');
+        return `${this.name}${this.get.required ? '' : '?'}: ${optionsJoinedType}`;
+    }
 }
 export const combobox = (name) => new ComboBoxFieldBuilder(name, 'combobox');

package/dist/fields/date/index.d.ts

@@ -3,8 +3,8 @@ import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.
 import type { DefaultValueFn, FormField } from '../types.js';
 export declare const date: (name: string) => DateFieldBuilder;
 export declare class DateFieldBuilder extends FormFieldBuilder<DateField> {
-    _metaUrl: string;
     constructor(name: string);
+    get dataType(): DataType;
     get component(): import("svelte").Component<{
         path: string;
         config: DateFieldBuilder;
@@ -14,8 +14,8 @@ export declare class DateFieldBuilder extends FormFieldBuilder<DateField> {
         value: Date | undefined;
     }, {}, "">;
     defaultValue(value: Date | DefaultValueFn<Date>): this;
-    get dataType(): DataType;
     isTitle(): this;
+    protected generateType(): string;
 }
 /****************************************************/
 export type DateField = FormField & {