sh3-core 0.16.0 → 0.17.0

package/dist/fields/decoration.js

@@ -0,0 +1,199 @@
+/*
+ * Decoration overlay layer.
+ *
+ * One root-level <div class="sh3-decoration-layer"> per Sh3 instance, lazily
+ * created on first attachDecoration. Pointer-events: none by default;
+ * decorations opt in for clickable UI by setting pointer-events: auto on
+ * their own root element.
+ *
+ * Reflow triggers (shared across all decorations):
+ *   - window resize  (debounced to one frame)
+ *   - scroll on field's nearest scrollable ancestor (delegated)
+ *   - ResizeObserver on the field element (handles parent reflows)
+ *
+ * Auto-dispose on contribution unregister via contributions.onChange.
+ */
+import { onChange as onContributionsChange, list as listContributions } from '../contributions';
+import { FIELD_POINT_ID } from './types';
+const decorations = new Set();
+let layer = null;
+let resizeListener = null;
+let contributionsUnsubscribe = null;
+let rafScheduled = false;
+function ensureLayer() {
+    if (layer && layer.isConnected)
+        return layer;
+    const el = document.createElement('div');
+    el.className = 'sh3-decoration-layer';
+    el.style.cssText = 'position: fixed; inset: 0; pointer-events: none;';
+    document.body.appendChild(el);
+    layer = el;
+    if (!resizeListener) {
+        resizeListener = () => scheduleReflowAll();
+        window.addEventListener('resize', resizeListener);
+    }
+    if (!contributionsUnsubscribe) {
+        contributionsUnsubscribe = onContributionsChange(FIELD_POINT_ID, () => {
+            const present = new Set();
+            for (const entry of listContributions(FIELD_POINT_ID)) {
+                present.add(addrKey({
+                    shardId: entry.owner.shardId,
+                    slotId: entry.owner.slotId,
+                    fieldId: entry.descriptor.fieldId,
+                }));
+            }
+            for (const dec of Array.from(decorations)) {
+                if (!present.has(addrKey(dec.addr)))
+                    disposeDecoration(dec);
+            }
+        });
+    }
+    return el;
+}
+function addrKey(a) {
+    var _a;
+    return `${a.shardId}::${(_a = a.slotId) !== null && _a !== void 0 ? _a : ''}::${a.fieldId}`;
+}
+function findEntry(addr) {
+    var _a, _b;
+    for (const entry of listContributions(FIELD_POINT_ID)) {
+        if (entry.owner.shardId !== addr.shardId)
+            continue;
+        if (((_a = entry.owner.slotId) !== null && _a !== void 0 ? _a : undefined) !== ((_b = addr.slotId) !== null && _b !== void 0 ? _b : undefined))
+            continue;
+        if (entry.descriptor.fieldId !== addr.fieldId)
+            continue;
+        return entry;
+    }
+    return undefined;
+}
+function entryElement(entry) {
+    const d = entry.descriptor;
+    if (d.shape === 'element')
+        return d.element;
+    if (d.shape === 'imperative' || d.shape === 'readonly')
+        return d.element;
+    return undefined;
+}
+function nearestScrollableAncestor(el) {
+    let cur = el.parentElement;
+    while (cur) {
+        const s = getComputedStyle(cur);
+        if (/auto|scroll/.test(s.overflowY) || /auto|scroll/.test(s.overflowX))
+            return cur;
+        cur = cur.parentElement;
+    }
+    return window;
+}
+function reflow(dec) {
+    var _a, _b;
+    if (dec.disposed)
+        return;
+    const rect = dec.target.getBoundingClientRect();
+    dec.wrapper.style.left = `${rect.left}px`;
+    dec.wrapper.style.top = `${rect.top}px`;
+    dec.wrapper.style.width = `${rect.width}px`;
+    dec.wrapper.style.height = `${rect.height}px`;
+    (_b = (_a = dec.handle) === null || _a === void 0 ? void 0 : _a.update) === null || _b === void 0 ? void 0 : _b.call(_a, rect);
+}
+function scheduleReflowAll() {
+    if (rafScheduled)
+        return;
+    rafScheduled = true;
+    requestAnimationFrame(() => {
+        rafScheduled = false;
+        for (const dec of decorations)
+            reflow(dec);
+    });
+}
+function disposeDecoration(dec) {
+    var _a, _b;
+    if (dec.disposed)
+        return;
+    dec.disposed = true;
+    decorations.delete(dec);
+    dec.resizeObserver.disconnect();
+    if (dec.scrollAncestor === window) {
+        window.removeEventListener('scroll', dec.scrollListener, true);
+    }
+    else {
+        dec.scrollAncestor.removeEventListener('scroll', dec.scrollListener);
+    }
+    try {
+        (_b = (_a = dec.handle) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    catch (err) {
+        console.error('[sh3] decoration dispose threw', err);
+    }
+    if (dec.wrapper.parentElement)
+        dec.wrapper.parentElement.removeChild(dec.wrapper);
+}
+export function attachDecoration(addr, factory) {
+    const entry = findEntry(addr);
+    if (!entry) {
+        throw new Error(`unknown field: ${addrKey(addr)}`);
+    }
+    const target = entryElement(entry);
+    if (!target) {
+        throw new Error(`field has no element to anchor to: ${addrKey(addr)}`);
+    }
+    const layerEl = ensureLayer();
+    const rect = target.getBoundingClientRect();
+    const result = factory({ element: target, rect });
+    let element;
+    let handle = null;
+    if (result instanceof HTMLElement) {
+        element = result;
+    }
+    else {
+        element = result.element;
+        handle = result;
+    }
+    const wrapper = document.createElement('div');
+    wrapper.className = 'sh3-decoration';
+    wrapper.style.cssText =
+        `position: absolute; left: ${rect.left}px; top: ${rect.top}px; ` +
+            `width: ${rect.width}px; height: ${rect.height}px; pointer-events: none;`;
+    wrapper.appendChild(element);
+    layerEl.appendChild(wrapper);
+    const scrollAncestor = nearestScrollableAncestor(target);
+    const dec = {
+        addr,
+        element,
+        wrapper,
+        target,
+        handle,
+        resizeObserver: new ResizeObserver(() => scheduleReflowAll()),
+        scrollAncestor,
+        scrollListener: () => scheduleReflowAll(),
+        disposed: false,
+    };
+    dec.resizeObserver.observe(target);
+    if (scrollAncestor === window) {
+        window.addEventListener('scroll', dec.scrollListener, true);
+    }
+    else {
+        scrollAncestor.addEventListener('scroll', dec.scrollListener);
+    }
+    decorations.add(dec);
+    return () => disposeDecoration(dec);
+}
+/** Test-only: tear everything down and reset module state. */
+export function __resetDecorationLayerForTest() {
+    var _a;
+    for (const dec of Array.from(decorations))
+        disposeDecoration(dec);
+    decorations.clear();
+    if (layer && layer.isConnected)
+        (_a = layer.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(layer);
+    layer = null;
+    if (resizeListener) {
+        window.removeEventListener('resize', resizeListener);
+        resizeListener = null;
+    }
+    if (contributionsUnsubscribe) {
+        contributionsUnsubscribe();
+        contributionsUnsubscribe = null;
+    }
+    rafScheduled = false;
+}

package/dist/fields/decoration.svelte.test.d.ts

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

package/dist/fields/decoration.svelte.test.js

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { __resetContributionsForTest, register, } from '../contributions/registry';
+import { attachDecoration, __resetDecorationLayerForTest } from './decoration';
+import { FIELD_POINT_ID } from './types';
+function registerElementField(shardId, fieldId, el) {
+    register(FIELD_POINT_ID, {
+        owner: { shardId },
+        descriptor: {
+            shape: 'imperative',
+            fieldId,
+            label: fieldId,
+            kind: 'string',
+            get: () => '',
+            element: el,
+        },
+    });
+}
+async function flushFrame() {
+    await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+describe('attachDecoration', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+        __resetDecorationLayerForTest();
+        document.body.innerHTML = '';
+    });
+    it('rejects when the target field is unknown', () => {
+        expect(() => attachDecoration({ shardId: 'a', fieldId: 'x' }, () => document.createElement('div'))).toThrow(/unknown field/);
+    });
+    it('rejects when the target field has no element', () => {
+        register(FIELD_POINT_ID, {
+            owner: { shardId: 'a' },
+            descriptor: {
+                shape: 'imperative', fieldId: 'abstract', label: 'A', kind: 'string',
+                get: () => '',
+            },
+        });
+        expect(() => attachDecoration({ shardId: 'a', fieldId: 'abstract' }, () => document.createElement('div'))).toThrow(/no element/);
+    });
+    it('mounts the factory result into the overlay layer', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        registerElementField('a', 'x', target);
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => {
+            const d = document.createElement('div');
+            d.dataset.kind = 'badge';
+            return d;
+        });
+        const layer = document.querySelector('.sh3-decoration-layer');
+        expect(layer).not.toBeNull();
+        expect(layer.querySelector('[data-kind="badge"]')).not.toBeNull();
+    });
+    it('sets absolute position matching the target rect', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        target.getBoundingClientRect = () => ({
+            x: 10, y: 20, width: 100, height: 30,
+            top: 20, left: 10, right: 110, bottom: 50,
+            toJSON() { return this; },
+        });
+        registerElementField('a', 'x', target);
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => document.createElement('div'));
+        const wrapper = document.querySelector('.sh3-decoration');
+        expect(wrapper.style.position).toBe('absolute');
+        expect(wrapper.style.left).toBe('10px');
+        expect(wrapper.style.top).toBe('20px');
+        expect(wrapper.style.width).toBe('100px');
+        expect(wrapper.style.height).toBe('30px');
+    });
+    it('disposer removes the wrapper and calls handle.dispose', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        registerElementField('a', 'x', target);
+        const dispose = vi.fn();
+        const off = attachDecoration({ shardId: 'a', fieldId: 'x' }, () => ({
+            element: document.createElement('div'),
+            dispose,
+        }));
+        expect(document.querySelector('.sh3-decoration')).not.toBeNull();
+        off();
+        expect(document.querySelector('.sh3-decoration')).toBeNull();
+        expect(dispose).toHaveBeenCalledTimes(1);
+    });
+    it('disposer is idempotent (double-call no-op)', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        registerElementField('a', 'x', target);
+        const dispose = vi.fn();
+        const off = attachDecoration({ shardId: 'a', fieldId: 'x' }, () => ({
+            element: document.createElement('div'),
+            dispose,
+        }));
+        off();
+        off();
+        expect(dispose).toHaveBeenCalledTimes(1);
+    });
+    it('decoration is auto-disposed when the contribution is unregistered', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        const unreg = register(FIELD_POINT_ID, {
+            owner: { shardId: 'a' },
+            descriptor: {
+                shape: 'imperative',
+                fieldId: 'x',
+                label: 'x',
+                kind: 'string',
+                get: () => '',
+                element: target,
+            },
+        });
+        const dispose = vi.fn();
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => ({
+            element: document.createElement('div'),
+            dispose,
+        }));
+        expect(document.querySelector('.sh3-decoration')).not.toBeNull();
+        unreg();
+        expect(document.querySelector('.sh3-decoration')).toBeNull();
+        expect(dispose).toHaveBeenCalledTimes(1);
+    });
+    it('factory may return a plain HTMLElement (no DecorationHandle)', () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        registerElementField('a', 'x', target);
+        const off = attachDecoration({ shardId: 'a', fieldId: 'x' }, () => {
+            const el = document.createElement('div');
+            el.id = 'plain';
+            return el;
+        });
+        expect(document.getElementById('plain')).not.toBeNull();
+        off();
+    });
+    it('window resize triggers a wrapper reflow', async () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        let rect = { x: 0, y: 0, width: 50, height: 20, top: 0, left: 0, right: 50, bottom: 20 };
+        target.getBoundingClientRect = () => rect;
+        registerElementField('a', 'x', target);
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => document.createElement('div'));
+        const wrapper = document.querySelector('.sh3-decoration');
+        expect(wrapper.style.left).toBe('0px');
+        rect = { x: 100, y: 200, width: 50, height: 20, top: 200, left: 100, right: 150, bottom: 220 };
+        window.dispatchEvent(new Event('resize'));
+        await flushFrame();
+        expect(wrapper.style.left).toBe('100px');
+        expect(wrapper.style.top).toBe('200px');
+    });
+    it('handle.update is called with the new rect on reflow', async () => {
+        const target = document.createElement('input');
+        document.body.appendChild(target);
+        let rect = { x: 0, y: 0, width: 50, height: 20, top: 0, left: 0, right: 50, bottom: 20 };
+        target.getBoundingClientRect = () => rect;
+        registerElementField('a', 'x', target);
+        const update = vi.fn();
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => ({
+            element: document.createElement('div'),
+            update,
+        }));
+        rect = { x: 5, y: 5, width: 60, height: 25, top: 5, left: 5, right: 65, bottom: 30 };
+        window.dispatchEvent(new Event('resize'));
+        await flushFrame();
+        expect(update).toHaveBeenCalled();
+        expect(update.mock.calls.at(-1)[0].left).toBe(5);
+    });
+    it('overlay layer is created lazily on first attach and reused thereafter', () => {
+        expect(document.querySelector('.sh3-decoration-layer')).toBeNull();
+        const t1 = document.createElement('input');
+        const t2 = document.createElement('input');
+        document.body.append(t1, t2);
+        registerElementField('a', 'x', t1);
+        registerElementField('a', 'y', t2);
+        attachDecoration({ shardId: 'a', fieldId: 'x' }, () => document.createElement('div'));
+        attachDecoration({ shardId: 'a', fieldId: 'y' }, () => document.createElement('div'));
+        expect(document.querySelectorAll('.sh3-decoration-layer').length).toBe(1);
+        expect(document.querySelectorAll('.sh3-decoration').length).toBe(2);
+    });
+});

package/dist/fields/dispatch.d.ts

@@ -0,0 +1,22 @@
+import type { FieldAddress, FieldView, FieldKind } from './types';
+export interface ListFieldsOpts {
+    slotId?: string;
+    shardId?: string;
+    walker?: 'off' | 'fallback' | 'always';
+    kind?: FieldKind;
+}
+export declare function listFields(opts?: ListFieldsOpts): FieldView[];
+export declare function getField(addr: FieldAddress): unknown;
+/**
+ * Internal helper exported for the walker too: writes to a native form
+ * element and dispatches both 'input' and 'change' events.
+ */
+export declare function writeElement(el: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, value: unknown): void;
+export declare function setField(addr: FieldAddress, value: unknown): Promise<void>;
+/**
+ * Synthesize FieldView descriptors for native form elements + [data-sh3-field]
+ * within `container`. Walker output uses shardId === WALKER_SHARD_ID and
+ * carries the passed `slotId` for addressability. Skips elements that are
+ * already the `element` ref of an element-ref contribution.
+ */
+export declare function walkSlotContainer(slotId: string, container: HTMLElement): FieldView[];

package/dist/fields/dispatch.js

@@ -0,0 +1,254 @@
+/*
+ * Field dispatch — read from contributions registry, route get/set against
+ * descriptor shape. Element-ref I/O lives here; walker (DOM scan) lives in
+ * the same module but is only exercised by walkSlot (added Task 6).
+ */
+import { list as listContributions } from '../contributions';
+import { FIELD_POINT_ID, WALKER_SHARD_ID } from './types';
+function getEntries() {
+    return listContributions(FIELD_POINT_ID);
+}
+function findEntry(addr) {
+    var _a, _b;
+    for (const entry of getEntries()) {
+        if (entry.owner.shardId !== addr.shardId)
+            continue;
+        if (((_a = entry.owner.slotId) !== null && _a !== void 0 ? _a : undefined) !== ((_b = addr.slotId) !== null && _b !== void 0 ? _b : undefined))
+            continue;
+        if (entry.descriptor.fieldId !== addr.fieldId)
+            continue;
+        return entry;
+    }
+    return undefined;
+}
+function descriptorReadonly(d) {
+    if (d.shape === 'readonly')
+        return true;
+    if (d.shape === 'imperative')
+        return typeof d.set !== 'function';
+    return false; // 'element' shape is always read-write
+}
+function descriptorElement(d) {
+    if (d.shape === 'element')
+        return d.element;
+    if (d.shape === 'imperative' || d.shape === 'readonly')
+        return d.element;
+    return undefined;
+}
+function entryToView(entry) {
+    const d = entry.descriptor;
+    const view = {
+        shardId: entry.owner.shardId,
+        fieldId: d.fieldId,
+        label: d.label,
+        kind: d.kind,
+        description: d.description,
+        enumValues: d.enumValues,
+        readonly: descriptorReadonly(d),
+        source: 'contributed',
+    };
+    if (entry.owner.slotId !== undefined)
+        view.slotId = entry.owner.slotId;
+    const el = descriptorElement(d);
+    if (el !== undefined)
+        view.element = el;
+    return view;
+}
+export function listFields(opts = {}) {
+    const out = [];
+    for (const entry of getEntries()) {
+        if (opts.shardId !== undefined && entry.owner.shardId !== opts.shardId)
+            continue;
+        if (opts.slotId !== undefined && entry.owner.slotId !== opts.slotId)
+            continue;
+        if (opts.kind !== undefined && entry.descriptor.kind !== opts.kind)
+            continue;
+        out.push(entryToView(entry));
+    }
+    // Walker integration is added in Task 6 (walkSlot is no-op here for now).
+    return out;
+}
+function readImperativeOrReadonly(d) {
+    return d.get();
+}
+function readElementRef(d) {
+    const el = d.element;
+    if (el instanceof HTMLInputElement && el.type === 'checkbox')
+        return el.checked;
+    return el.value;
+}
+export function getField(addr) {
+    var _a;
+    const entry = findEntry(addr);
+    if (!entry) {
+        throw new Error(`unknown field: ${addr.shardId}::${(_a = addr.slotId) !== null && _a !== void 0 ? _a : ''}::${addr.fieldId}`);
+    }
+    const d = entry.descriptor;
+    if (d.shape === 'element')
+        return readElementRef(d);
+    return readImperativeOrReadonly(d);
+}
+/**
+ * Internal helper exported for the walker too: writes to a native form
+ * element and dispatches both 'input' and 'change' events.
+ */
+export function writeElement(el, value) {
+    if (el instanceof HTMLInputElement && el.type === 'checkbox') {
+        el.checked = Boolean(value);
+    }
+    else {
+        el.value = String(value);
+    }
+    el.dispatchEvent(new Event('input', { bubbles: true }));
+    el.dispatchEvent(new Event('change', { bubbles: true }));
+}
+export async function setField(addr, value) {
+    var _a, _b, _c;
+    const entry = findEntry(addr);
+    if (!entry) {
+        throw new Error(`unknown field: ${addr.shardId}::${(_a = addr.slotId) !== null && _a !== void 0 ? _a : ''}::${addr.fieldId}`);
+    }
+    const d = entry.descriptor;
+    if (d.shape === 'readonly') {
+        throw new Error(`field is read-only: ${addr.shardId}::${(_b = addr.slotId) !== null && _b !== void 0 ? _b : ''}::${addr.fieldId}`);
+    }
+    if (d.shape === 'imperative') {
+        if (typeof d.set !== 'function') {
+            throw new Error(`field is read-only: ${addr.shardId}::${(_c = addr.slotId) !== null && _c !== void 0 ? _c : ''}::${addr.fieldId}`);
+        }
+        await d.set(value);
+        return;
+    }
+    // 'element' shape
+    writeElement(d.element, value);
+}
+/* ── Walker ────────────────────────────────────────────────────────── */
+const SKIP_INPUT_TYPES = new Set(['submit', 'button', 'reset', 'file', 'hidden']);
+function inferInputKind(el) {
+    if (el.type === 'number')
+        return 'number';
+    if (el.type === 'checkbox')
+        return 'boolean';
+    return 'string';
+}
+function selectEnumValues(sel) {
+    return Array.from(sel.options).map((o) => o.value);
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9.\-_ ]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function findLabelText(el) {
+    if (el.id) {
+        const explicit = el.ownerDocument.querySelector(`label[for="${CSS.escape(el.id)}"]`);
+        if (explicit && explicit.textContent)
+            return explicit.textContent;
+    }
+    let cur = el.parentElement;
+    while (cur) {
+        if (cur.tagName === 'LABEL' && cur.textContent)
+            return cur.textContent;
+        cur = cur.parentElement;
+    }
+    return null;
+}
+function deriveFieldId(el, fallbackIndex) {
+    const dataAttr = el.getAttribute('data-sh3-field');
+    if (dataAttr && dataAttr.length > 0)
+        return dataAttr;
+    const name = el.name;
+    if (name)
+        return name;
+    // Prefer an explicit/ancestor <label> over a bare id: a label is more
+    // human-meaningful, and id values are often opaque (e.g. framework-generated).
+    const label = findLabelText(el);
+    if (label) {
+        const slug = slugify(label);
+        if (slug.length > 0)
+            return slug;
+    }
+    if (el.id)
+        return el.id;
+    const placeholder = el.placeholder;
+    if (placeholder) {
+        const slug = slugify(placeholder);
+        if (slug.length > 0)
+            return slug;
+    }
+    return `field-${fallbackIndex}`;
+}
+function deriveLabel(el) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = findLabelText(el)) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : el.placeholder) !== null && _c !== void 0 ? _c : null;
+}
+function isWalkerCandidate(el) {
+    if (el.hasAttribute('data-sh3-field'))
+        return true;
+    if (el instanceof HTMLInputElement)
+        return !SKIP_INPUT_TYPES.has(el.type);
+    if (el instanceof HTMLTextAreaElement)
+        return true;
+    if (el instanceof HTMLSelectElement)
+        return true;
+    return false;
+}
+/**
+ * Synthesize FieldView descriptors for native form elements + [data-sh3-field]
+ * within `container`. Walker output uses shardId === WALKER_SHARD_ID and
+ * carries the passed `slotId` for addressability. Skips elements that are
+ * already the `element` ref of an element-ref contribution.
+ */
+export function walkSlotContainer(slotId, container) {
+    var _a;
+    const contributedElements = new Set();
+    for (const entry of getEntries()) {
+        const d = entry.descriptor;
+        if (d.shape === 'element')
+            contributedElements.add(d.element);
+    }
+    const all = container.querySelectorAll('input, textarea, select, [data-sh3-field]');
+    const out = [];
+    let fallbackCounter = 0;
+    for (const el of Array.from(all)) {
+        if (!isWalkerCandidate(el))
+            continue;
+        if (contributedElements.has(el))
+            continue;
+        let kind = 'string';
+        let enumValues;
+        if (el instanceof HTMLInputElement) {
+            kind = inferInputKind(el);
+        }
+        else if (el instanceof HTMLSelectElement) {
+            kind = 'enum';
+            enumValues = selectEnumValues(el);
+        }
+        else if (el.hasAttribute('data-sh3-field')) {
+            const declared = el.getAttribute('data-sh3-field-kind');
+            if (declared && ['string', 'number', 'integer', 'boolean', 'enum', 'json'].includes(declared)) {
+                kind = declared;
+            }
+        }
+        const fieldId = deriveFieldId(el, fallbackCounter);
+        if (/^field-\d+$/.test(fieldId))
+            fallbackCounter += 1;
+        const view = {
+            shardId: WALKER_SHARD_ID,
+            slotId,
+            fieldId,
+            label: (_a = deriveLabel(el)) !== null && _a !== void 0 ? _a : fieldId,
+            kind,
+            readonly: false,
+            source: 'walker',
+            element: el,
+        };
+        if (enumValues !== undefined)
+            view.enumValues = enumValues;
+        out.push(view);
+    }
+    return out;
+}

package/dist/fields/dispatch.test.d.ts

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