rimecms 0.22.0

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

@@ -0,0 +1,61 @@
+import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import type { DefaultValueFn, FormField } from '../types.js';
+export declare const textarea: (name: string) => TextAreaFieldBuilder;
+export declare class TextAreaFieldBuilder extends FormFieldBuilder<TextAreaField> {
+    _metaUrl: string;
+    get component(): import("svelte").Component<import("./component/props").TextAreaFieldProps, {}, "">;
+    get cell(): null;
+    defaultValue(value: string | DefaultValueFn<string>): this;
+    isTitle(): this;
+    placeholder(str: string): this;
+    compile(): {
+        type: "textarea";
+        live?: boolean | undefined;
+        condition?: ((doc: any, siblings: any) => boolean) | undefined;
+        width?: import("../types.js").FieldWidth | undefined;
+        className?: string | undefined;
+        component: import("svelte").Component<any>;
+        cell: import("svelte").Component<any> | undefined;
+        access: {
+            create: import("../types.js").FieldAccess;
+            read: import("../types.js").FieldAccess;
+            update: import("../types.js").FieldAccess;
+        };
+        name: string;
+        hidden?: boolean | undefined;
+        validate?: import("../types.js").FieldValidationFunc<any> | undefined;
+        required?: boolean | undefined;
+        localized?: boolean | undefined;
+        label?: string | undefined;
+        hint?: string | undefined;
+        table?: {
+            cell?: import("svelte").Component<{
+                value: any;
+            }> | undefined;
+            sort?: boolean | undefined;
+            position: number;
+        } | undefined;
+        hooks?: {
+            beforeRead?: import("../types.js").FieldHook<any>[] | undefined;
+            beforeSave?: import("../types.js").FieldHook<any>[] | undefined;
+            beforeValidate?: import("../types.js").FieldHookShared<any>[] | undefined;
+            onChange?: import("../types.js").FieldHookClient[] | undefined;
+        } | undefined;
+        defaultValue?: string | DefaultValueFn<string> | undefined;
+        isEmpty: (value: unknown) => boolean;
+        isTitle?: true | undefined;
+        placeholder: string;
+    } & {
+        component: import("svelte").Component<any>;
+        cell?: import("svelte").Component<{
+            value: any;
+        }> | null;
+    };
+}
+/****************************************************/
+export type TextAreaField = FormField & {
+    type: 'textarea';
+    defaultValue?: string | DefaultValueFn<string>;
+    isTitle?: true;
+    placeholder: string;
+};

package/dist/fields/textarea/index.js

@@ -0,0 +1,37 @@
+import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import { capitalize } from '../../util/string.js';
+import TextArea from './component/TextArea.svelte';
+export const textarea = (name) => new TextAreaFieldBuilder(name, 'textarea');
+export class TextAreaFieldBuilder extends FormFieldBuilder {
+    //
+    _metaUrl = import.meta.url;
+    get component() {
+        return TextArea;
+    }
+    get cell() {
+        return null;
+    }
+    defaultValue(value) {
+        this.field.defaultValue = value;
+        return this;
+    }
+    isTitle() {
+        this.field.isTitle = true;
+        return this;
+    }
+    placeholder(str) {
+        this.field.placeholder = str;
+        return this;
+    }
+    compile() {
+        if (!this.field.validate) {
+            this.field.validate = (value) => {
+                return typeof value === 'string' || 'Should be a string';
+            };
+        }
+        if (!this.field.placeholder) {
+            this.field.placeholder = this.field.label || capitalize(this.field.name);
+        }
+        return super.compile();
+    }
+}

package/dist/fields/textarea/index.server.d.ts

@@ -0,0 +1,4 @@
+import type { ToSchema, ToType } from '../index.server.js';
+import type { TextAreaFieldBuilder } from './index.js';
+export declare const toSchema: ToSchema<TextAreaFieldBuilder>;
+export declare const toType: ToType<TextAreaFieldBuilder>;

package/dist/fields/textarea/index.server.js

@@ -0,0 +1,12 @@
+import { templateUniqueRequired } from '../../adapter-sqlite/generate-schema/templates.server.js';
+import { getSchemaColumnNames } from '../../adapter-sqlite/generate-schema/util.js';
+export const toSchema = (field, parentPath) => {
+    const { camel, snake } = getSchemaColumnNames({ name: field.name, parentPath });
+    const suffix = templateUniqueRequired({ unique: false, required: field.raw.required });
+    if (field._generateSchema)
+        return field._generateSchema({ camel, snake, suffix });
+    return `${camel}: text('${snake}')${suffix}`;
+};
+export const toType = (field) => {
+    return `${field.name}${field.raw.required ? '' : '?'}: string`;
+};

package/dist/fields/time/component/Time.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+	import { Field } from '../../../panel/components/fields/index.js';
+	import { root } from '../../../panel/components/fields/root.svelte.js';
+	import { Input } from '../../../panel/components/ui/input/index.js';
+	import { Clock } from '@lucide/svelte';
+	import type { TimeFieldProps } from './props';
+
+	const { path, config, form }: TimeFieldProps = $props();
+	const field = $derived(form.useField(path || config.name, config));
+
+	const onInput = (event: Event) => {
+		field.value = (event.target as HTMLInputElement).value;
+	};
+</script>
+
+<fieldset class="rz-time-field {config.className || ''}" use:root={field}>
+	<Field.Label {config} for={path || config.name} />
+	<div class="rz-time-field__input-wrapper">
+		<Input
+			type="time"
+			id={path}
+			name={path}
+			data-error={field.error ? '' : null}
+			value={field.value}
+			oninput={onInput}
+		/>
+		<span class="rz-time-field__icon">
+			<Clock size="12" />
+		</span>
+	</div>
+	<Field.Hint {config} />
+	<Field.Error error={field.error} />
+</fieldset>
+
+<style>
+	.rz-time-field__input-wrapper {
+		display: flex;
+		width: 200px;
+		position: relative;
+		:global {
+			.rz-input {
+				display: block;
+			}
+		}
+	}
+
+	.rz-time-field__icon {
+		position: absolute;
+		top: 0;
+		bottom: 0;
+		right: var(--rz-size-4);
+		display: flex;
+		align-items: center;
+	}
+</style>

package/dist/fields/time/component/Time.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { TimeFieldProps } from './props';
+declare const Time: import("svelte").Component<TimeFieldProps, {}, "">;
+type Time = ReturnType<typeof Time>;
+export default Time;

package/dist/fields/time/component/props.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentFormContext } from '../../../panel/context/documentForm.svelte';
+import type { TimeField } from '../index.js';
+export type TimeFieldProps = {
+    path?: string;
+    config: TimeField;
+    form: DocumentFormContext;
+};

package/dist/fields/time/component/props.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import type { DefaultValueFn, FormField } from '../types.js';
+export declare const time: (name: string) => TimeFieldBuilder;
+export declare class TimeFieldBuilder extends FormFieldBuilder<TimeField> {
+    _metaUrl: string;
+    constructor(name: string);
+    get component(): import("svelte").Component<import("./component/props").TimeFieldProps, {}, "">;
+    defaultValue(value: string | DefaultValueFn<string>): this;
+}
+/****************************************************/
+export type TimeField = FormField & {
+    type: 'time';
+    defaultValue?: string | DefaultValueFn<string>;
+    unique?: boolean;
+};

package/dist/fields/time/index.js

@@ -0,0 +1,24 @@
+import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import TimeComponent from './component/Time.svelte';
+export const time = (name) => new TimeFieldBuilder(name);
+export class TimeFieldBuilder extends FormFieldBuilder {
+    //
+    _metaUrl = import.meta.url;
+    constructor(name) {
+        super(name, 'time');
+        this.field.defaultValue = '08:00';
+        this.field.validate = (value) => {
+            if (typeof value === 'string' && /^([01]?[0-9]|2[0-3]):[0-5][0-9]$/.test(value)) {
+                return true;
+            }
+            return 'incorrect time format ' + value;
+        };
+    }
+    get component() {
+        return TimeComponent;
+    }
+    defaultValue(value) {
+        this.field.defaultValue = value;
+        return this;
+    }
+}

package/dist/fields/time/index.server.d.ts

@@ -0,0 +1,4 @@
+import type { ToSchema, ToType } from '../index.server.js';
+import type { TimeFieldBuilder } from './index.js';
+export declare const toSchema: ToSchema<TimeFieldBuilder>;
+export declare const toType: ToType<TimeFieldBuilder>;

package/dist/fields/time/index.server.js

@@ -0,0 +1,12 @@
+import { templateUniqueRequired } from '../../adapter-sqlite/generate-schema/templates.server.js';
+import { getSchemaColumnNames } from '../../adapter-sqlite/generate-schema/util.js';
+export const toSchema = (field, parentPath) => {
+    const { camel, snake } = getSchemaColumnNames({ name: field.name, parentPath });
+    const suffix = templateUniqueRequired(field.raw);
+    if (field._generateSchema)
+        return field._generateSchema({ camel, snake, suffix });
+    return `${camel}: text('${snake}')${suffix}`;
+};
+export const toType = (field) => {
+    return `${field.name}${!field.raw.required ? '?' : ''}: string`;
+};

package/dist/fields/toggle/component/Cell.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import Switch from '../../../panel/components/ui/switch/switch.svelte';
+
+	type Props = {
+		value: boolean | null;
+	};
+
+	const { value }: Props = $props();
+</script>
+
+<div class="rz-toggle-cell">
+	<Switch disabled checked={!!value} />
+</div>
+
+<style>
+	.rz-toggle-cell {
+		scale: 0.8;
+		transform-origin: left;
+	}
+</style>

package/dist/fields/toggle/component/Cell.svelte.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    value: boolean | null;
+};
+declare const Cell: import("svelte").Component<Props, {}, "">;
+type Cell = ReturnType<typeof Cell>;
+export default Cell;

package/dist/fields/toggle/component/Toggle.svelte

@@ -0,0 +1,45 @@
+<script lang="ts">
+	import { Field } from '../../../panel/components/fields/index.js';
+	import { root } from '../../../panel/components/fields/root.svelte.js';
+	import { Switch } from '../../../panel/components/ui/switch/index.js';
+	import { slugify } from '../../../util/string.js';
+	import type { ToggleProps } from './props';
+
+	const { path, config, form }: ToggleProps = $props();
+
+	const field = $derived(form.useField<boolean>(path, config));
+	const inputId = slugify(`${form.key}-${path}`);
+
+	const onCheckedChange = (bool: boolean) => {
+		field.value = bool;
+	};
+</script>
+
+<fieldset class="rz-toggle-field {config.className || ''}" use:root={field}>
+	<div class="rz-toggle-field-wrap">
+		<Switch data-error={field.error ? '' : null} checked={field.value} {onCheckedChange} id={inputId} />
+		<Field.LabelFor {config} for={inputId} />
+	</div>
+	<Field.Hint {config} />
+</fieldset>
+
+<style>
+	.rz-toggle-field-wrap {
+		display: flex;
+		align-items: center;
+	}
+	.rz-toggle-field-wrap > :global(* + *) {
+		margin-left: var(--rz-size-2);
+	}
+
+	.rz-toggle-field {
+		margin-top: var(--rz-size-3);
+		margin-bottom: var(--rz-size-3);
+	}
+
+	.rz-toggle-field :global {
+		.rz-field-hint {
+			margin-left: var(--rz-size-8);
+		}
+	}
+</style>

package/dist/fields/toggle/component/Toggle.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToggleProps } from './props';
+declare const Toggle: import("svelte").Component<ToggleProps, {}, "">;
+type Toggle = ReturnType<typeof Toggle>;
+export default Toggle;

package/dist/fields/toggle/component/props.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentFormContext } from '../../../panel/context/documentForm.svelte.js';
+import type { ToggleField } from '../index.js';
+export type ToggleProps = {
+    path: string;
+    config: ToggleField;
+    form: DocumentFormContext;
+};

package/dist/fields/toggle/component/props.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,58 @@
+import { BooleanFieldBuilder } from '../../core/fields/builders/boolean.js';
+import type { DefaultValueFn, FormField } from '../types.js';
+export declare class ToggleFieldBuilder extends BooleanFieldBuilder<ToggleField> {
+    _metaUrl: string;
+    constructor(name: string);
+    get component(): import("svelte").Component<import("./component/props").ToggleProps, {}, "">;
+    get cell(): import("svelte").Component<{
+        value: boolean | null;
+    }, {}, "">;
+    defaultValue(value: boolean | DefaultValueFn<boolean>): this;
+    compile(): {
+        type: "toggle";
+        defaultValue?: (boolean | DefaultValueFn<boolean>) | undefined;
+        live?: boolean | undefined;
+        condition?: ((doc: any, siblings: any) => boolean) | undefined;
+        width?: import("../types.js").FieldWidth | undefined;
+        className?: string | undefined;
+        component: import("svelte").Component<any>;
+        cell: import("svelte").Component<any> | undefined;
+        access: {
+            create: import("../types.js").FieldAccess;
+            read: import("../types.js").FieldAccess;
+            update: import("../types.js").FieldAccess;
+        };
+        name: string;
+        hidden?: boolean | undefined;
+        validate?: import("../types.js").FieldValidationFunc<any> | undefined;
+        required?: boolean | undefined;
+        localized?: boolean | undefined;
+        label?: string | undefined;
+        hint?: string | undefined;
+        table?: {
+            cell?: import("svelte").Component<{
+                value: any;
+            }> | undefined;
+            sort?: boolean | undefined;
+            position: number;
+        } | undefined;
+        hooks?: {
+            beforeRead?: import("../types.js").FieldHook<any>[] | undefined;
+            beforeSave?: import("../types.js").FieldHook<any>[] | undefined;
+            beforeValidate?: import("../types.js").FieldHookShared<any>[] | undefined;
+            onChange?: import("../types.js").FieldHookClient[] | undefined;
+        } | undefined;
+        isEmpty: (value: unknown) => boolean;
+    } & {
+        component: import("svelte").Component<any>;
+        cell?: import("svelte").Component<{
+            value: any;
+        }> | null;
+    };
+}
+export declare const toggle: (name: string) => ToggleFieldBuilder;
+/****************************************************/
+export interface ToggleField extends FormField {
+    type: 'toggle';
+    defaultValue?: boolean | DefaultValueFn<boolean>;
+}

package/dist/fields/toggle/index.js

@@ -0,0 +1,31 @@
+import { BooleanFieldBuilder } from '../../core/fields/builders/boolean.js';
+import Cell from './component/Cell.svelte';
+import Toggle from './component/Toggle.svelte';
+export class ToggleFieldBuilder extends BooleanFieldBuilder {
+    //
+    _metaUrl = import.meta.url;
+    constructor(name) {
+        super(name, 'toggle');
+        this.field.isEmpty = (value) => typeof value !== 'boolean';
+        this.field.defaultValue = false;
+    }
+    get component() {
+        return Toggle;
+    }
+    get cell() {
+        return Cell;
+    }
+    defaultValue(value) {
+        this.field.defaultValue = value;
+        return this;
+    }
+    compile() {
+        if (!this.field.validate) {
+            this.field.validate = (value) => {
+                return typeof value === 'boolean' || 'Should be a boolean';
+            };
+        }
+        return super.compile();
+    }
+}
+export const toggle = (name) => new ToggleFieldBuilder(name);

package/dist/fields/toggle/index.server.d.ts

@@ -0,0 +1,4 @@
+import type { ToSchema, ToType } from '../index.server.js';
+import type { ToggleFieldBuilder } from './index.js';
+export declare const toSchema: ToSchema<ToggleFieldBuilder>;
+export declare const toType: ToType<ToggleFieldBuilder>;

package/dist/fields/toggle/index.server.js

@@ -0,0 +1,12 @@
+import { templateUniqueRequired } from '../../adapter-sqlite/generate-schema/templates.server.js';
+import { getSchemaColumnNames } from '../../adapter-sqlite/generate-schema/util.js';
+export const toSchema = (field, parentPath) => {
+    const { camel, snake } = getSchemaColumnNames({ name: field.name, parentPath });
+    const suffix = templateUniqueRequired(field.raw);
+    if (field._generateSchema)
+        return field._generateSchema({ camel, snake, suffix });
+    return `${camel}: integer('${snake}', { mode: 'boolean' })${suffix}`;
+};
+export const toType = (field) => {
+    return `${field.name}${field.raw.required ? '?' : ''}: boolean`;
+};

package/dist/fields/tree/component/AddItemButton.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+	import type { FieldBuilder } from '../../../core/fields/builders';
+	import { emptyValuesFromFieldConfig, isFormField } from '../../../core/fields/util';
+	import type { Field } from '../../types.js';
+	import Button from '../../../panel/components/ui/button/button.svelte';
+
+	import type { Dic } from '../../../util/types';
+	import { Plus } from '@lucide/svelte';
+	import type { Snippet } from 'svelte';
+
+	type AddItem = (emptyValues: Dic) => void;
+	type Props = {
+		size: 'default' | 'sm';
+		class: string;
+		fields: FieldBuilder<Field>[];
+		addItem: AddItem;
+		children: Snippet;
+	};
+	const { class: className, fields, addItem, size, children }: Props = $props();
+
+	const add = () => {
+		const empty = emptyValuesFromFieldConfig(fields.map((f) => f.raw).filter(isFormField));
+		addItem(empty);
+	};
+</script>
+
+<Button icon={Plus} class="rz-add-item-button {className}" onclick={() => add()} variant="outline" {size}>
+	<span>
+		{@render children()}
+	</span>
+</Button>
+
+<style>
+	:global {
+		.rz-add-item-button {
+			gap: var(--rz-size-2);
+		}
+	}
+</style>

package/dist/fields/tree/component/AddItemButton.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { FieldBuilder } from '../../../core/fields/builders';
+import type { Field } from '../../types.js';
+import type { Dic } from '../../../util/types';
+import type { Snippet } from 'svelte';
+type AddItem = (emptyValues: Dic) => void;
+type Props = {
+    size: 'default' | 'sm';
+    class: string;
+    fields: FieldBuilder<Field>[];
+    addItem: AddItem;
+    children: Snippet;
+};
+declare const AddItemButton: import("svelte").Component<Props, {}, "">;
+type AddItemButton = ReturnType<typeof AddItemButton>;
+export default AddItemButton;

package/dist/fields/tree/component/Cell.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	type Dic = Record<string, any>;
+
+	type Props = {
+		value: Dic | null;
+	};
+
+	const { value }: Props = $props();
+
+	const blockCount = $derived(value ? value.length : 0);
+	const blockLabel = $derived(blockCount === 1 ? 'block' : 'blocks');
+</script>
+
+<div class="rz-blocks-cell">
+	{blockCount}
+	{blockLabel}
+</div>
+
+<style>
+	.rz-blocks-cell {
+		min-width: var(--rz-size-24);
+	}
+</style>

package/dist/fields/tree/component/Cell.svelte.d.ts

@@ -0,0 +1,7 @@
+type Dic = Record<string, any>;
+type Props = {
+    value: Dic | null;
+};
+declare const Cell: import("svelte").Component<Props, {}, "">;
+type Cell = ReturnType<typeof Cell>;
+export default Cell;

package/dist/fields/tree/component/ToggleBlockButton.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import { ChevronDown, ChevronUp } from '@lucide/svelte';
+
+	type Props = { toggle: any; isOpen: boolean };
+	const { toggle, isOpen }: Props = $props();
+</script>
+
+<button class="rz-toggle-block" type="button" onclick={toggle}>
+	{#if isOpen}
+		<ChevronUp size="12" />
+	{:else}
+		<ChevronDown size="12" />
+	{/if}
+</button>
+
+<style>
+	button {
+		padding: var(--rz-size-2);
+	}
+</style>

package/dist/fields/tree/component/ToggleBlockButton.svelte.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    toggle: any;
+    isOpen: boolean;
+};
+declare const ToggleBlockButton: import("svelte").Component<Props, {}, "">;
+type ToggleBlockButton = ReturnType<typeof ToggleBlockButton>;
+export default ToggleBlockButton;