@craft-ts/core 0.7.0-beta.13

package/src/lib/form/craft-field.js

@@ -0,0 +1,586 @@
+import { computed, isSignal, signal } from '../host/craft-compat';
+/** Returns whether a value exposes the public Craft field contract. */
+export function isCraftField(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return (typeof candidate.value === 'function' &&
+        typeof candidate.set === 'function' &&
+        typeof candidate.ɵregisterControl === 'function');
+}
+const FIELD_INTERNALS_TOKEN = Symbol('CraftFieldInternals');
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+function readAtSegment(parent, segment) {
+    if (parent == null)
+        return undefined;
+    return parent[segment];
+}
+function writeAtSegment(parent, segment, value) {
+    if (Array.isArray(parent)) {
+        const next = parent.slice();
+        next[segment] = value;
+        return next;
+    }
+    if (isPlainObject(parent)) {
+        return { ...parent, [segment]: value };
+    }
+    return parent;
+}
+function pathsEqual(left, right) {
+    return (left.length === right.length &&
+        left.every((segment, index) => segment === right[index]));
+}
+function createCraftFieldInternals(options) {
+    const path = options.path;
+    const schemaErrorSources = options.kind === 'root'
+        ? []
+        : options.link.parent.__schemaErrorSources;
+    const schemaErrorRevision = options.kind === 'root'
+        ? signal(0)
+        : options.link.parent.__schemaErrorRevision;
+    // ---------- Value adapter ----------
+    const readRaw = () => {
+        if (options.kind === 'root')
+            return options.backing.read();
+        return options.link.read(options.link.parent.__raw());
+    };
+    const setRaw = (next) => {
+        if (options.kind === 'root') {
+            options.backing.set(next);
+            return;
+        }
+        const parent = options.link.parent;
+        const nextParent = options.link.write(parent.__raw(), next);
+        parent.__setRaw(nextParent);
+    };
+    const valueSignal = options.kind === 'root'
+        ? options.backing.asReadonly()
+        : computed(() => options.link.read(options.link.parent.value()));
+    // ---------- Dirty / Touched ----------
+    const localDirty = signal(false);
+    const localTouched = signal(false);
+    const childDirty = signal(false);
+    const childTouched = signal(false);
+    const dirty = computed(() => localDirty() || childDirty());
+    const touched = computed(() => localTouched() || childTouched());
+    const recomputeChildDirty = () => {
+        let any = false;
+        for (const child of children.values()) {
+            if (child.dirty()) {
+                any = true;
+                break;
+            }
+        }
+        childDirty.set(any);
+    };
+    const recomputeChildTouched = () => {
+        let any = false;
+        for (const child of children.values()) {
+            if (child.touched()) {
+                any = true;
+                break;
+            }
+        }
+        childTouched.set(any);
+    };
+    // ---------- State sources (hidden / disabled / readonly) ----------
+    // Plain mutable arrays + a single revision signal so that registration
+    // (which can happen lazily during template render) does not write to a
+    // tracked signal — Angular forbids signal writes during render (NG0600).
+    // The first read of any computed below captures whatever has been registered
+    // so far, and subsequent reads track the inner source signals individually.
+    const hiddenSources = [];
+    const disabledSources = [];
+    const readonlySources = [];
+    const registrationRevision = signal(0);
+    const hiddenLocal = computed(() => {
+        registrationRevision();
+        return hiddenSources.some((src) => src());
+    });
+    const disabledLocal = computed(() => {
+        registrationRevision();
+        return disabledSources.some((src) => src());
+    });
+    const readonlyLocal = computed(() => {
+        registrationRevision();
+        return readonlySources.some((src) => src());
+    });
+    const validators = [];
+    const schemaErrors = computed(() => {
+        schemaErrorRevision();
+        if (hiddenLocal() || disabledLocal() || readonlyLocal())
+            return [];
+        return schemaErrorSources
+            .flatMap((source) => source())
+            .filter((entry) => pathsEqual(entry.path, path))
+            .map((entry) => entry.error);
+    });
+    const validatorOutputs = computed(() => {
+        registrationRevision();
+        return validators.map((v) => ({
+            result: v.result(),
+            attribute: v.attribute?.(),
+        }));
+    });
+    const errors = computed(() => {
+        // Track revision so newly-registered children/validators invalidate this
+        // computed at the next tick.
+        registrationRevision();
+        if (hiddenLocal() || disabledLocal() || readonlyLocal())
+            return [];
+        const list = [];
+        for (const out of validatorOutputs()) {
+            const r = out.result;
+            if (r === undefined)
+                continue;
+            if (typeof r === 'object' && r !== null && 'pending' in r && r.pending === true) {
+                continue;
+            }
+            if (Array.isArray(r)) {
+                for (const item of r)
+                    list.push(item);
+            }
+            else {
+                list.push(r);
+            }
+        }
+        list.push(...schemaErrors());
+        // Aggregate errors from all child fields so that parent validity reflects
+        // the entire sub-tree (a parent is invalid if any descendant is invalid).
+        for (const child of children.values()) {
+            const childErrors = child.errors();
+            if (childErrors.length > 0) {
+                for (const e of childErrors)
+                    list.push(e);
+            }
+        }
+        return list;
+    });
+    const pending = computed(() => {
+        registrationRevision();
+        if (hiddenLocal() || disabledLocal() || readonlyLocal())
+            return false;
+        if (validatorOutputs().some((out) => typeof out.result === 'object' &&
+            out.result !== null &&
+            'pending' in out.result &&
+            out.result.pending === true)) {
+            return true;
+        }
+        for (const child of children.values()) {
+            if (child.pending())
+                return true;
+        }
+        return false;
+    });
+    const schemaInvalid = computed(() => {
+        if (options.kind !== 'root')
+            return false;
+        if (hiddenLocal() || disabledLocal() || readonlyLocal())
+            return false;
+        schemaErrorRevision();
+        return schemaErrorSources.some((source) => source().length > 0);
+    });
+    const invalid = computed(() => schemaInvalid() || errors().length > 0);
+    const valid = computed(() => !invalid() && !pending());
+    // ---------- Native constraint signals ----------
+    const constraintSignal = (target, fallback) => computed(() => {
+        let acc = fallback;
+        let found = false;
+        for (const out of validatorOutputs()) {
+            const a = out.attribute;
+            if (a && a.kind === 'native-constraint' && a.target === target) {
+                if (target === 'required') {
+                    acc = (acc || a.value);
+                    found = true;
+                }
+                else {
+                    acc = a.value;
+                    found = true;
+                }
+            }
+        }
+        return found ? acc : fallback;
+    });
+    const required = constraintSignal('required', false);
+    const min = constraintSignal('min', undefined);
+    const max = constraintSignal('max', undefined);
+    const minLength = constraintSignal('minLength', undefined);
+    const maxLength = constraintSignal('maxLength', undefined);
+    const pattern = constraintSignal('pattern', undefined);
+    // ---------- Disabled reasons ----------
+    const disabledReasonSources = [];
+    const disabledReasons = computed(() => {
+        registrationRevision();
+        const out = [];
+        for (const src of disabledReasonSources) {
+            const r = src();
+            if (typeof r === 'string' && r.length > 0)
+                out.push(r);
+        }
+        return out;
+    });
+    // ---------- Children registry ----------
+    const children = new Map();
+    // ---------- Reset trigger ----------
+    const resetTriggerCount = signal(0);
+    // ---------- Inherited state from parent ----------
+    const inheritedDisabled = options.kind === 'child' ? options.link.parent.disabled : signal(false);
+    const inheritedHidden = options.kind === 'child' ? options.link.parent.hidden : signal(false);
+    const inheritedReadonly = options.kind === 'child' ? options.link.parent.readonly : signal(false);
+    const disabled = computed(() => inheritedDisabled() || disabledLocal());
+    const hidden = computed(() => inheritedHidden() || hiddenLocal());
+    const readonlyComputed = computed(() => inheritedReadonly() || readonlyLocal());
+    // ---------- Control syncers ----------
+    const syncers = new Set();
+    // ---------- Field methods ----------
+    const set = (next) => {
+        setRaw(next);
+        if (!localDirty())
+            localDirty.set(true);
+        if (options.kind === 'child') {
+            options.link.parent.__propagateDirty(true);
+        }
+    };
+    const patch = (fn) => {
+        const current = readRaw();
+        const partial = fn(current);
+        if (current && typeof current === 'object' && !Array.isArray(current)) {
+            set({ ...current, ...partial });
+        }
+        else {
+            set(partial);
+        }
+    };
+    const propagateDirty = (childIsDirty) => {
+        if (childIsDirty) {
+            childDirty.set(true);
+        }
+        else {
+            recomputeChildDirty();
+        }
+        if (options.kind === 'child') {
+            options.link.parent.__propagateDirty(dirty());
+        }
+    };
+    const propagateTouched = (childIsTouched) => {
+        if (childIsTouched) {
+            childTouched.set(true);
+        }
+        else {
+            recomputeChildTouched();
+        }
+        if (options.kind === 'child') {
+            options.link.parent.__propagateTouched(touched());
+        }
+    };
+    const markTouched = () => {
+        if (!localTouched())
+            localTouched.set(true);
+        if (options.kind === 'child')
+            options.link.parent.__propagateTouched(true);
+    };
+    const markUntouched = () => {
+        localTouched.set(false);
+        if (options.kind === 'child')
+            options.link.parent.__propagateTouched(false);
+    };
+    const markDirty = () => {
+        if (!localDirty())
+            localDirty.set(true);
+        if (options.kind === 'child')
+            options.link.parent.__propagateDirty(true);
+    };
+    const markPristine = () => {
+        localDirty.set(false);
+        if (options.kind === 'child')
+            options.link.parent.__propagateDirty(false);
+    };
+    const resetCascade = () => {
+        localDirty.set(false);
+        localTouched.set(false);
+        childDirty.set(false);
+        childTouched.set(false);
+        for (const child of children.values()) {
+            child.__resetCascade();
+        }
+        resetTriggerCount.update((v) => v + 1);
+        for (const syncer of syncers) {
+            syncer.resync?.();
+        }
+    };
+    const reset = (initialValue) => {
+        if (initialValue !== undefined) {
+            setRaw(initialValue);
+        }
+        resetCascade();
+        if (options.kind === 'child') {
+            options.link.parent.__propagateDirty(false);
+            options.link.parent.__propagateTouched(false);
+        }
+    };
+    // ---------- Registration helpers ----------
+    const registerControl = (syncer) => {
+        syncers.add(syncer);
+        return () => {
+            syncers.delete(syncer);
+            syncer.destroy?.();
+        };
+    };
+    const bumpRevision = () => {
+        // The revision signal exists to invalidate computed signals when the
+        // registration set changes AFTER it has already been observed. Writing
+        // to a signal during template render is forbidden (NG0600), so we defer
+        // the bump to a microtask. In the common case (registration happens
+        // before any read), the bump is harmless; the first read will already
+        // have captured the registered entries.
+        queueMicrotask(() => registrationRevision.update((v) => v + 1));
+    };
+    const registerValidator = (validator, identifier) => {
+        const ctxField = field;
+        const out = validator({ value: valueSignal, field: ctxField, identifier });
+        const entry = { result: out.result, attribute: out.attribute };
+        validators.push(entry);
+        bumpRevision();
+        return () => {
+            const i = validators.indexOf(entry);
+            if (i >= 0)
+                validators.splice(i, 1);
+            bumpRevision();
+        };
+    };
+    const registerSchemaErrorSource = (source) => {
+        schemaErrorSources.push(source);
+        schemaErrorRevision.update((value) => value + 1);
+        return () => {
+            const index = schemaErrorSources.indexOf(source);
+            if (index >= 0)
+                schemaErrorSources.splice(index, 1);
+            schemaErrorRevision.update((value) => value + 1);
+        };
+    };
+    const registerStateBinding = (kind, source) => {
+        const target = kind === 'hidden' ? hiddenSources : kind === 'disabled' ? disabledSources : readonlySources;
+        target.push(source);
+        bumpRevision();
+        return () => {
+            const i = target.indexOf(source);
+            if (i >= 0)
+                target.splice(i, 1);
+            bumpRevision();
+        };
+    };
+    const registerDisabledReason = (source) => {
+        disabledReasonSources.push(source);
+        bumpRevision();
+        return () => {
+            const i = disabledReasonSources.indexOf(source);
+            if (i >= 0)
+                disabledReasonSources.splice(i, 1);
+            bumpRevision();
+        };
+    };
+    // ---------- Field value sync to syncers ----------
+    // Note: syncers call writeValue when registering; the directive itself sets up an effect
+    // to track value changes. We don't auto-sync here to avoid effect ownership issues.
+    const field = {
+        value: valueSignal,
+        set,
+        patch,
+        reset,
+        dirty,
+        touched,
+        hidden,
+        disabled,
+        readonly: readonlyComputed,
+        pending,
+        invalid,
+        valid,
+        errors,
+        required,
+        min,
+        max,
+        minLength,
+        maxLength,
+        pattern,
+        disabledReasons,
+        ɵregisterControl: registerControl,
+        ɵmarkTouched: markTouched,
+        ɵmarkUntouched: markUntouched,
+        ɵmarkDirty: markDirty,
+        ɵmarkPristine: markPristine,
+        ɵregisterValidator: registerValidator,
+        ɵregisterSchemaErrorSource: registerSchemaErrorSource,
+        ɵregisterStateBinding: registerStateBinding,
+        ɵregisterDisabledReason: registerDisabledReason,
+        ɵresetTrigger: resetTriggerCount.asReadonly(),
+        ɵpath: path,
+        __raw: readRaw,
+        __setRaw: setRaw,
+        __children: children,
+        __resetTriggerCount: resetTriggerCount,
+        __propagateDirty: propagateDirty,
+        __propagateTouched: propagateTouched,
+        __resetCascade: resetCascade,
+        __bumpRevision: bumpRevision,
+        __schemaErrorSources: schemaErrorSources,
+        __schemaErrorRevision: schemaErrorRevision,
+    };
+    return field;
+}
+function createTreeProxy(internals) {
+    const proxy = new Proxy(internals, {
+        get(_target, prop, receiver) {
+            if (typeof prop === 'symbol') {
+                if (prop === FIELD_INTERNALS_TOKEN)
+                    return internals;
+                return Reflect.get(internals, prop, receiver);
+            }
+            if (prop in internals) {
+                return internals[prop];
+            }
+            const widenedInternals = internals;
+            // Array-like: support `length` and `item(index)`
+            if (prop === 'item') {
+                return (index) => getOrCreateChild(widenedInternals, index);
+            }
+            if (prop === 'length') {
+                return computed(() => {
+                    const v = internals.value();
+                    return Array.isArray(v) ? v.length : 0;
+                });
+            }
+            // Numeric index -> array child
+            if (/^\d+$/.test(prop)) {
+                return getOrCreateChild(widenedInternals, Number(prop));
+            }
+            // Otherwise treat as object property child
+            return getOrCreateChild(widenedInternals, prop);
+        },
+        has(_target, prop) {
+            if (typeof prop === 'symbol')
+                return prop === FIELD_INTERNALS_TOKEN;
+            if (prop in internals)
+                return true;
+            return true;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(internals);
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            return Object.getOwnPropertyDescriptor(internals, prop);
+        },
+    });
+    return proxy;
+}
+function getOrCreateChild(parent, segment) {
+    const existing = parent.__children.get(segment);
+    if (existing) {
+        return existing.__proxy;
+    }
+    const link = {
+        parent,
+        segment,
+        read: (p) => readAtSegment(p, segment),
+        write: (p, next) => writeAtSegment(p, segment, next),
+    };
+    const childInternals = createCraftFieldInternals({
+        kind: 'child',
+        link,
+        path: [...parent.ɵpath, segment],
+    });
+    parent.__children.set(segment, childInternals);
+    const childProxy = createTreeProxy(childInternals);
+    childInternals.__proxy = childProxy;
+    // Notify parent so its computed `errors`/`pending`/`valid` re-evaluate and
+    // pick up the newly-added child.
+    parent.__bumpRevision();
+    return childProxy;
+}
+/**
+ * Create a Craft field tree from an external mutable backing store.
+ * Used by `insertForm` to bridge the Craft `state()` signal into the field tree.
+ */
+export function createCraftFieldTree(backing) {
+    const internals = createCraftFieldInternals({
+        kind: 'root',
+        backing,
+        path: [],
+    });
+    const proxy = createTreeProxy(internals);
+    internals.__proxy = proxy;
+    return proxy;
+}
+/**
+ * Create a Craft field tree backed by a writable signal (convenience for tests / standalone usage).
+ */
+export function craftField(initial) {
+    if (isSignal(initial) && typeof initial.set === 'function') {
+        const s = initial;
+        return createCraftFieldTree({
+            read: () => s(),
+            set: (next) => s.set(next),
+            asReadonly: () => s.asReadonly(),
+        });
+    }
+    if (isSignal(initial)) {
+        const s = initial;
+        return createCraftFieldTree({
+            read: () => s(),
+            set: () => {
+                throw new Error('craftField: cannot set on a readonly signal source.');
+            },
+            asReadonly: () => s,
+        });
+    }
+    const s = signal(initial);
+    return createCraftFieldTree({
+        read: () => s(),
+        set: (next) => s.set(next),
+        asReadonly: () => s.asReadonly(),
+    });
+}
+/** @internal */
+export function ɵgetCraftFieldInternals(field) {
+    return field[FIELD_INTERNALS_TOKEN] ?? field;
+}
+/**
+ * @internal
+ * Create (or return a cached) child field whose value is **derived** from the
+ * parent via an arbitrary lens (read + write functions), rather than indexed
+ * by an object key or array index.
+ *
+ * The returned child plugs into the same `ParentLink` machinery used for
+ * structural children, so dirty/touched/disabled/hidden/validation/reset
+ * cascades work exactly the same way.
+ *
+ * Two calls with the same `name` on the same parent return the same child
+ * instance — the lens passed on the first call wins.
+ */
+export function ɵgetOrCreateDerivedChild(parent, name, lens) {
+    const parentInternals = ɵgetCraftFieldInternals(parent);
+    const existing = parentInternals.__children.get(name);
+    if (existing) {
+        return existing.__proxy;
+    }
+    const link = {
+        parent: parentInternals,
+        segment: name,
+        read: lens.read,
+        write: lens.write,
+    };
+    const childInternals = createCraftFieldInternals({
+        kind: 'child',
+        link: link,
+        path: [...parentInternals.ɵpath, name],
+    });
+    parentInternals.__children.set(name, childInternals);
+    const childProxy = createTreeProxy(childInternals);
+    childInternals.__proxy = childProxy;
+    return childProxy;
+}
+//# sourceMappingURL=craft-field.js.map