@modufolio/panel 0.1.0

package/dist/Components/Fields/TextareaField.vue.d.ts

@@ -0,0 +1,111 @@
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    required: boolean;
+    modelValue: string | number;
+    id: string;
+    label: string;
+    placeholder: string;
+    help: string;
+    error: string;
+    disabled: boolean;
+    readonly: boolean;
+    width: string;
+    rows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Fields/TimePickerField.vue.d.ts

@@ -0,0 +1,115 @@
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** `HH:mm` in 24-hour form, whatever the viewer's locale displays. */
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    min: {
+        type: StringConstructor;
+        default: string;
+    };
+    max: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Seconds between selectable values; 60 keeps the control at whole minutes. */
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** `HH:mm` in 24-hour form, whatever the viewer's locale displays. */
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    min: {
+        type: StringConstructor;
+        default: string;
+    };
+    max: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Seconds between selectable values; 60 keeps the control at whole minutes. */
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    required: boolean;
+    min: string;
+    max: string;
+    modelValue: string;
+    id: string;
+    label: string;
+    help: string;
+    error: string;
+    disabled: boolean;
+    width: string;
+    step: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Fields/ToggleButtonsField.vue.d.ts

@@ -0,0 +1,93 @@
+import { PropType } from 'vue';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colors: {
+        type: PropType<Record<string, string>>;
+        default: () => {};
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colors: {
+        type: PropType<Record<string, string>>;
+        default: () => {};
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    required: boolean;
+    modelValue: string | number | boolean;
+    label: string;
+    help: string;
+    error: string;
+    disabled: boolean;
+    width: string;
+    colors: Record<string, string>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Fields/ToggleField.vue.d.ts

@@ -0,0 +1,95 @@
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    help: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    id: string;
+    label: string;
+    help: string;
+    error: string;
+    disabled: boolean;
+    width: string;
+    color: string;
+    description: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Fields/fieldRegistry.d.ts

@@ -0,0 +1,25 @@
+import { Component } from 'vue';
+/**
+ * The field-type → component registry, in a module of its own.
+ *
+ * Extracted from useBlueprint.ts so the arrows point one way: the registry
+ * lazily imports RepeaterField, and RepeaterField needs
+ * `resolveFieldComponent` for its sub-fields — while both lived in
+ * useBlueprint, the two files imported each other. The cycle was tolerable
+ * at runtime (one edge dynamic, one type-only), but a composable and a
+ * component depending on each other is the kind of knot that only ever
+ * tightens; now field components import this module, never the composable.
+ */
+type FieldLoader = () => Promise<Component | {
+    default: Component;
+}>;
+/**
+ * Register (or override) a field type. This is the application's extension
+ * seam: field components with app-specific dependencies (writer, rich-text,
+ * block-editor, ...) are registered at boot instead of living in the panel.
+ *
+ *   registerFieldType('writer', () => import('@/Components/Fields/WriterField.vue'))
+ */
+export declare function registerFieldType(type: string, loader: FieldLoader): void;
+export declare function resolveFieldComponent(type: string): Promise<Component>;
+export {};

package/dist/Components/Fields/fieldsFromSpec.d.ts

@@ -0,0 +1,10 @@
+import { FieldDef } from './useBlueprint';
+export declare function fieldsFromSpec(fields: any[]): FieldDef[];
+/**
+ * Starting values for a set of declared fields.
+ *
+ * Collection-valued fields start as `[]`: their components iterate the model
+ * (`[...modelValue]`, `v-for`), and an explicit null overrides a prop default,
+ * so null does not degrade gracefully — it throws.
+ */
+export declare function initialValues(fields: any[], record?: Record<string, any> | null): Record<string, unknown>;

package/dist/Components/Fields/useBlueprint.d.ts

@@ -0,0 +1,94 @@
+import { ComputedRef } from 'vue';
+import { FieldWidth } from './useFieldWidth';
+import { ValidationRule } from './validation';
+import { resolveFieldComponent } from './fieldRegistry';
+/** A value, or a function returning it — so callers can pass reactive sources. */
+export type MaybeGetter<T> = T | (() => T);
+/** Field types shipped with the panel. */
+export type BuiltinFieldType = 'text' | 'textarea' | 'select' | 'multiselect' | 'toggle' | 'checkbox' | 'range' | 'date' | 'datetime' | 'time' | 'date-range' | 'file' | 'color' | 'belongs-to' | 'repeater' | 'toggle-buttons';
+/**
+ * Built-ins plus anything an application registers via registerFieldType()
+ * (e.g. 'writer', 'rich-text', 'block-editor'). The `string & {}` keeps
+ * autocomplete for built-ins while accepting custom types.
+ */
+export type FieldType = BuiltinFieldType | (string & {});
+export interface OptionItem {
+    label: string;
+    value: string | number | boolean;
+    disabled?: boolean;
+}
+export interface FieldDef {
+    /** Field type — maps to a field component */
+    type: FieldType;
+    /** Form key — used for v-model binding */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Grid column width (default: 'full') */
+    width?: FieldWidth;
+    /** Mark field as required */
+    required?: boolean;
+    /** Help text shown below the field */
+    help?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Options for select / multiselect / toggle-buttons */
+    options?: OptionItem[];
+    /** Extra props passed directly to the field component */
+    props?: Record<string, unknown>;
+    /** Conditional visibility — the field is hidden when this evaluates false */
+    when?: Condition;
+    /** Client-side validation, evaluated in order; the first failure is shown */
+    rules?: ValidationRule[];
+    /** Sub-field declarations, for container types such as `repeater` */
+    fields?: FieldDef[];
+}
+export type ConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'not_in' | 'contains' | 'empty' | 'not_empty';
+/**
+ * A single comparison against another field's value.
+ *
+ *   ['status', 'published']            // implicit '=='
+ *   ['status', '!=', 'draft']
+ *   ['cover', 'not_empty']
+ */
+export type ConditionTuple = [key: string, operator: 'empty' | 'not_empty'] | [key: string, operator: ConditionOperator, value: unknown] | [key: string, value: unknown];
+/**
+ * Conditions compose explicitly through `all` / `any` rather than by array
+ * nesting depth. Depth-as-grammar reads compactly but is invisible to
+ * TypeScript and easy to misread; naming the combinator costs a few characters
+ * and keeps the shape checkable.
+ */
+export type Condition = ((form: Record<string, unknown>) => boolean) | ConditionTuple | {
+    all: Condition[];
+} | {
+    any: Condition[];
+};
+/** Evaluate a condition against the current form values. */
+export declare function evaluateCondition(condition: Condition, form: Record<string, unknown>): boolean;
+export { registerFieldType, resolveFieldComponent } from './fieldRegistry';
+/**
+ * Converts a FieldDef array into reactive field state for use with BlueprintForm.
+ *
+ * @param fields - Array of field definitions
+ * @param form   - Reactive form object (e.g. from useForm())
+ *
+ * @example
+ * const { visibleFields, fieldProps } = useBlueprint(fields, form)
+ */
+export declare function useBlueprint(fields: MaybeGetter<FieldDef[]>, form: MaybeGetter<Record<string, unknown>>): {
+    visibleFields: ComputedRef<FieldDef[]>;
+    visibleData: ComputedRef<Record<string, unknown>>;
+    clientErrors: ComputedRef<Record<string, string>>;
+    isValid: ComputedRef<boolean>;
+    fieldProps: (field: FieldDef, errors?: Record<string, string>) => Record<string, unknown>;
+    resolveFieldComponent: typeof resolveFieldComponent;
+};
+/**
+ * Type-safe helper for defining a blueprint field array.
+ *
+ * @example
+ * const fields = defineBlueprint([
+ *   { type: 'text', key: 'name', label: 'Name', width: '1/2' },
+ * ])
+ */
+export declare function defineBlueprint(fields: FieldDef[]): FieldDef[];

package/dist/Components/Fields/useFieldWidth.d.ts

@@ -0,0 +1,10 @@
+import { ComputedRef } from 'vue';
+export type FieldWidth = '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 'full';
+export declare function useFieldWidth(getWidth: () => string): ComputedRef<string>;
+export declare const fieldWidthProp: {
+    readonly width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+};

package/dist/Components/Fields/validation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Field validation for blueprint forms.
+ *
+ * Rules are plain functions returning `true` or a message. There is no string
+ * mini-language ('min:3|max:5'): in TypeScript a parsed string throws away
+ * every bit of inference, while `min(3)` is checked at the call site and
+ * autocompletes.
+ *
+ * A rule never throws and never mutates — given a value and the surrounding
+ * form it answers one question, so rules stay trivially testable and can be
+ * evaluated in any order.
+ */
+export type ValidationRule = (value: unknown, form: Record<string, unknown>) => string | true;
+export declare const required: (message?: string) => ValidationRule;
+export declare const min: (limit: number, message?: string) => ValidationRule;
+export declare const max: (limit: number, message?: string) => ValidationRule;
+export declare const email: (message?: string) => ValidationRule;
+export declare const url: (message?: string) => ValidationRule;
+export declare const pattern: (regex: RegExp, message?: string) => ValidationRule;
+export declare const integer: (message?: string) => ValidationRule;
+/** Matches another field — confirm-password and the like. */
+export declare const same: (otherKey: string, message?: string) => ValidationRule;
+/**
+ * Build rules from a serialised spec, as a server-side blueprint declares them:
+ *
+ *     ['required' => true, 'max' => 300, 'email' => true]
+ *
+ * This is what lets a field be described once, on the server, and still be
+ * checked before a round trip. The server remains the authority — this only
+ * spares the user a submit to learn something already knowable.
+ *
+ * Unknown rule names are ignored rather than throwing: the server may know
+ * rules this client build does not, and refusing to render a form over one
+ * unrecognised key would be a much worse failure than skipping it.
+ */
+export declare function rulesFromSpec(spec: Record<string, unknown> | undefined): ValidationRule[];
+/**
+ * First failing message for a value, or null.
+ *
+ * Only the first is returned: a field shows one message at a time, and running
+ * on would report "too short" about a value the user has not finished typing.
+ */
+export declare function firstError(rules: ValidationRule[] | undefined, value: unknown, form: Record<string, unknown>): string | null;

package/dist/Components/Filters/DateRangeFilter.vue.d.ts

@@ -0,0 +1,92 @@
+import { PropType } from 'vue';
+interface DatePreset {
+    label: string;
+    days?: number;
+    type?: string;
+}
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: ObjectConstructor;
+        default: () => {
+            start: null;
+            end: null;
+        };
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    min: {
+        type: StringConstructor;
+        default: string;
+    };
+    max: {
+        type: StringConstructor;
+        default: string;
+    };
+    showPresets: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    presets: {
+        type: PropType<DatePreset[]>;
+        default: () => ({
+            label: string;
+            days: number;
+            type?: undefined;
+        } | {
+            label: string;
+            type: string;
+            days?: undefined;
+        })[];
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: ObjectConstructor;
+        default: () => {
+            start: null;
+            end: null;
+        };
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    min: {
+        type: StringConstructor;
+        default: string;
+    };
+    max: {
+        type: StringConstructor;
+        default: string;
+    };
+    showPresets: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    presets: {
+        type: PropType<DatePreset[]>;
+        default: () => ({
+            label: string;
+            days: number;
+            type?: undefined;
+        } | {
+            label: string;
+            type: string;
+            days?: undefined;
+        })[];
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    min: string;
+    max: string;
+    modelValue: Record<string, any>;
+    label: string;
+    showPresets: boolean;
+    presets: DatePreset[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;