@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/views/metadata-admin/view-item-normalize.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * view-item-normalize — list-shaping helpers for the Studio View admin.
+ *
+ * The framework exposes each view as a canonical first-class **ViewItem**
+ * (ADR-0017, "Object has-many View"), addressed as `<object>.<viewKey>`:
+ *
+ *   {
+ *     name: "crm_campaign.campaign_calendar",
+ *     object: "crm_campaign",
+ *     viewKind: "list",            // list-family | form-family discriminant
+ *     label: "Launch Calendar",
+ *     scope: "package",
+ *     config: {                    // ← the single-view spec lives here
+ *       type: "calendar",
+ *       data: { object: "crm_campaign" },
+ *       columns: ["name", "channel", "status"],
+ *       calendar: { startDateField: "start_date", … },
+ *     },
+ *   }
+ *
+ * The View editor (inspector + preview) reads this canonical shape directly
+ * (`draft.config`), so there is no load/save shape adapter. These helpers only
+ * shape the metadata LIST: hide the legacy aggregated container row and derive
+ * a display "type" for the list column.
+ */
+function isPlainObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * True when `item` is a **bare aggregated view container** — the legacy
+ * per-object `defineView({ list, form, listViews, formViews })` document
+ * the framework still registers under the bare `<object>` key for runtime
+ * back-compat (dual-read). It carries NO `viewKind` discriminant and holds
+ * at least one of the aggregate buckets.
+ *
+ * Studio expands every such container into independent `<object>.<viewKey>`
+ * ViewItems (including the defaults), so the container row is fully
+ * redundant in the metadata list and should be hidden there.
+ */
+export function isAggregatedViewContainer(item) {
+    if (!isPlainObject(item))
+        return false;
+    if (item.viewKind)
+        return false; // already an independent ViewItem
+    return Boolean(item.list || item.form || item.listViews || item.formViews);
+}
+/**
+ * Derive the display "type" of a view list row. Expanded ViewItems keep
+ * their display type under `config.type` (`grid` / `calendar` / `kanban`
+ * / …) and only the list/form *family* at the top level (`viewKind`); a
+ * legacy flat view carries `type` directly. Returns `undefined` when
+ * nothing is resolvable (e.g. an aggregated container).
+ */
+export function viewDisplayType(item) {
+    if (!isPlainObject(item))
+        return undefined;
+    const config = item.config;
+    if (isPlainObject(config) && typeof config.type === 'string')
+        return config.type;
+    if (typeof item.type === 'string')
+        return item.type;
+    if (item.viewKind === 'form')
+        return 'form';
+    if (item.viewKind === 'list')
+        return 'list';
+    return undefined;
+}

package/dist/views/metadata-admin/view-schema.d.ts

@@ -0,0 +1,16 @@
+import type { FormViewSpec } from './SchemaForm';
+type JsonSchema = Record<string, any>;
+/** JSONSchema for a single LIST-family view (grid/kanban/calendar/…). */
+export declare function getListVariantSchema(): JsonSchema | undefined;
+/** JSONSchema for a single FORM-family view. */
+export declare function getFormVariantSchema(): JsonSchema | undefined;
+/** JSONSchema for a single list column (ListColumn). */
+export declare function getListColumnSchema(): JsonSchema | undefined;
+/**
+ * The canonical authoring FormView, with the fields the curated inspector
+ * owns directly (columns / data / name) pruned from every section so they
+ * are not double-rendered. Everything else — including the type-conditional
+ * per-view-type sections — flows through verbatim from the spec.
+ */
+export declare function getViewForm(): FormViewSpec | undefined;
+export {};

package/dist/views/metadata-admin/view-schema.js

@@ -0,0 +1,107 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * view-schema.ts — the SINGLE source of truth for View authoring metadata,
+ * sourced directly from `@objectstack/spec` (the protocol) rather than
+ * hand-written field lists.
+ *
+ * Why: the View inspector must render the CORRECT config fields for EVERY
+ * view type (grid / kanban / calendar / gallery / gantt / timeline / chart)
+ * without hardcoding them. The spec already describes this:
+ *
+ *   • `viewForm`     — the canonical authoring FormView: sections with
+ *                      type-conditional `visibleOn` CEL predicates
+ *                      (`data.type == 'kanban'`, …). One section per view
+ *                      type, plus shared basics / filters / navigation.
+ *   • `ViewSchema`   — the zod schema for the whole (nested) View document.
+ *                      `properties.list` is the JSONSchema for a single
+ *                      list-family view; `properties.form` for a form view.
+ *   • `ListColumnSchema` — per-column property schema (width / align /
+ *                      pinned / summary / …).
+ *
+ * We convert the zod schemas to JSONSchema once (memoised) via zod 4's
+ * native `z.toJSONSchema`, and feed `{ form, schema }` straight into the
+ * existing {@link SchemaForm}. Adding a new view type or config prop to the
+ * spec therefore flows through automatically — zero code changes here.
+ */
+import { z } from 'zod';
+import { ViewSchema, ListColumnSchema, viewForm as specViewForm, } from '@objectstack/spec/ui';
+const TO_JSON_OPTS = { io: 'input', unrepresentable: 'any' };
+/** Fields the curated inspector owns directly, pruned from the spec form. */
+const FORM_FIELDS_OWNED_ELSEWHERE = new Set([
+    'columns', // managed by the live column canvas + per-column inspector
+    'data', // object binding rendered as a dedicated control
+    'name', // record identity — not user-editable here
+]);
+let _viewDocSchema;
+let _viewDocFailed = false;
+function viewDocSchema() {
+    if (_viewDocSchema || _viewDocFailed)
+        return _viewDocSchema;
+    try {
+        _viewDocSchema = z.toJSONSchema(ViewSchema, TO_JSON_OPTS);
+    }
+    catch (err) {
+        _viewDocFailed = true;
+        if (typeof console !== 'undefined') {
+            console.warn('[view-schema] failed to derive View JSONSchema from spec', err);
+        }
+    }
+    return _viewDocSchema;
+}
+/** JSONSchema for a single LIST-family view (grid/kanban/calendar/…). */
+export function getListVariantSchema() {
+    return viewDocSchema()?.properties?.list;
+}
+/** JSONSchema for a single FORM-family view. */
+export function getFormVariantSchema() {
+    return viewDocSchema()?.properties?.form;
+}
+let _listColumnSchema;
+let _listColumnFailed = false;
+/** JSONSchema for a single list column (ListColumn). */
+export function getListColumnSchema() {
+    if (_listColumnSchema || _listColumnFailed)
+        return _listColumnSchema;
+    try {
+        _listColumnSchema = z.toJSONSchema(ListColumnSchema, TO_JSON_OPTS);
+    }
+    catch (err) {
+        _listColumnFailed = true;
+        if (typeof console !== 'undefined') {
+            console.warn('[view-schema] failed to derive ListColumn JSONSchema from spec', err);
+        }
+    }
+    return _listColumnSchema;
+}
+let _viewForm;
+/**
+ * The canonical authoring FormView, with the fields the curated inspector
+ * owns directly (columns / data / name) pruned from every section so they
+ * are not double-rendered. Everything else — including the type-conditional
+ * per-view-type sections — flows through verbatim from the spec.
+ */
+export function getViewForm() {
+    if (_viewForm)
+        return _viewForm;
+    if (!specViewForm || typeof specViewForm !== 'object')
+        return undefined;
+    try {
+        const clone = JSON.parse(JSON.stringify(specViewForm));
+        for (const section of clone.sections ?? []) {
+            section.fields = (section.fields ?? []).filter((f) => {
+                const name = typeof f === 'string' ? f : f?.field;
+                return !FORM_FIELDS_OWNED_ELSEWHERE.has(name);
+            });
+        }
+        // Drop now-empty sections so we don't render bare headers.
+        clone.sections = (clone.sections ?? []).filter((s) => (s.fields ?? []).length > 0);
+        _viewForm = clone;
+    }
+    catch (err) {
+        if (typeof console !== 'undefined') {
+            console.warn('[view-schema] failed to prepare viewForm from spec', err);
+        }
+        return undefined;
+    }
+    return _viewForm;
+}

package/dist/views/metadata-admin/view-variant-model.d.ts

@@ -0,0 +1,23 @@
+export interface VariantBinding {
+    /** Draft key the body is stored under — always `config` for a ViewItem. */
+    storeKey: string;
+    /** Logical family ('list' | 'form') for labels + form detection. */
+    familyKey: string;
+    /** The view body object (`draft.config`). */
+    schema: Record<string, unknown>;
+}
+/** True when a family key denotes a form-family view (no column list). */
+export declare function isFormFamilyKey(key: string): boolean;
+/**
+ * Resolve the editable binding for a View draft. Returns a single-element
+ * array (the ViewItem `config` body) or empty when the draft carries no body
+ * yet (e.g. a not-yet-built create draft).
+ */
+export declare function resolveVariantBindings(draft: Record<string, unknown>): VariantBinding[];
+/** The view's single editable body, or undefined when none exists yet. */
+export declare function primaryVariantBinding(draft: Record<string, unknown>): VariantBinding | undefined;
+/**
+ * Resolve the binding addressed by a store key (a selection id's prefix).
+ * A ViewItem has a single body, so this collapses to the primary binding.
+ */
+export declare function bindingForStoreKey(draft: Record<string, unknown>, _storeKey: string | undefined): VariantBinding | undefined;

package/dist/views/metadata-admin/view-variant-model.js

@@ -0,0 +1,64 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * view-variant-model — resolves a View draft into its editable body.
+ *
+ * The framework exposes exactly ONE canonical, first-class shape for a view:
+ * the independent **ViewItem** (ADR-0017, "Object has-many View"):
+ *
+ *   { name, object, viewKind: 'list' | 'form', label, config: { type, … } }
+ *
+ * `config` is the single view body (a ListView for `viewKind:'list'`, a
+ * FormView for `viewKind:'form'`); `viewKind` is the family discriminator.
+ * The legacy aggregated container ({ list, form, listViews }) is authoring
+ * sugar that the backend expands into ViewItems at registration time and no
+ * longer surfaces through metadata reads — so the editor consumes the ViewItem
+ * shape directly, with no shape adaptation.
+ *
+ * A "binding" pairs the draft key the body lives under (`config`, used for
+ * `onPatch` + column selection ids like `config.columns[i]`) with its logical
+ * family (drives form-vs-list rendering + labels) and the body itself.
+ */
+/** Variant families that store a FORM-family view (no columns). */
+const FORM_FAMILY = new Set(['form', 'detail']);
+/** True when a family key denotes a form-family view (no column list). */
+export function isFormFamilyKey(key) {
+    return FORM_FAMILY.has(key);
+}
+function isPlainObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/** Map a stored `viewKind` (+ body `type`) to a logical family key. */
+function familyFromViewKind(viewKind, bodyType) {
+    if (typeof viewKind === 'string' && FORM_FAMILY.has(viewKind))
+        return viewKind;
+    if (typeof viewKind === 'string' && viewKind)
+        return 'list';
+    // No viewKind: infer from the body's layout `type`.
+    if (typeof bodyType === 'string' && FORM_FAMILY.has(bodyType))
+        return 'form';
+    return 'list';
+}
+/**
+ * Resolve the editable binding for a View draft. Returns a single-element
+ * array (the ViewItem `config` body) or empty when the draft carries no body
+ * yet (e.g. a not-yet-built create draft).
+ */
+export function resolveVariantBindings(draft) {
+    const config = draft.config;
+    if (isPlainObject(config)) {
+        const familyKey = familyFromViewKind(draft.viewKind, config.type);
+        return [{ storeKey: 'config', familyKey, schema: config }];
+    }
+    return [];
+}
+/** The view's single editable body, or undefined when none exists yet. */
+export function primaryVariantBinding(draft) {
+    return resolveVariantBindings(draft)[0];
+}
+/**
+ * Resolve the binding addressed by a store key (a selection id's prefix).
+ * A ViewItem has a single body, so this collapses to the primary binding.
+ */
+export function bindingForStoreKey(draft, _storeKey) {
+    return primaryVariantBinding(draft);
+}

package/dist/views/metadata-admin/widgets.d.ts

@@ -22,6 +22,52 @@ export interface WidgetContext {
     objectNames?: string[];
     /** Loading flag for the object list. */
     objectsLoading?: boolean;
+    /**
+     * Field catalog of the bound object. Drives the `field-ref` /
+     * `field-multi` pickers so View config props that reference a field
+     * (kanban.groupByField, calendar.startDateField, chart.xAxisField, …)
+     * render as dropdowns of the object's real fields instead of free text.
+     */
+    objectFields?: Array<{
+        name: string;
+        label?: string;
+        type?: string;
+    }>;
+    /** Loading flag for the field catalog. */
+    objectFieldsLoading?: boolean;
+    /**
+     * View catalog of the bound/source object. Drives the `view-ref` picker
+     * so `interfaceConfig.sourceView` renders as a dropdown of the source
+     * object's real views instead of a free-text name the author can typo.
+     */
+    objectViews?: Array<{
+        name: string;
+        label?: string;
+    }>;
+    /** Loading flag for the view catalog. */
+    objectViewsLoading?: boolean;
+    /**
+     * Action catalog of the bound/source object. Drives the `action-multi`
+     * picker so interface-page toolbar `buttons` reference the object's real
+     * actions (ActionSchema) instead of free-text — correct-by-construction.
+     */
+    objectActions?: Array<{
+        name: string;
+        label?: string;
+        locations?: string[];
+    }>;
+    /** Loading flag for the action catalog. */
+    objectActionsLoading?: boolean;
+    /**
+     * Per-value sub-schemas for the `dynamic-config` widget: a map from a parent
+     * field's value (e.g. the chosen driver id) to the JSON-Schema describing the
+     * config object for that value. Lets a single `config` field render different
+     * fields depending on a sibling selection (driver → connection settings).
+     */
+    dynamicSchemas?: Record<string, {
+        properties?: Record<string, any>;
+        required?: string[];
+    }>;
 }
 export interface WidgetProps {
     id?: string;
@@ -64,5 +110,47 @@ export interface WidgetProps {
     formData?: Record<string, unknown>;
 }
 export type WidgetRenderer = (props: WidgetProps) => React.ReactElement;
+/**
+ * Resolve a stored `sourceView` value against a source object's view catalog,
+ * mirroring the runtime resolver (InterfaceListPage.resolveSourceView): a value
+ * resolves if it's an exact view name, a bare name matching a view's
+ * `<object>.<name>` suffix, or the special `default`/`list` (→ object default
+ * view). `showStored` is true when the stored value needs a synthesized option
+ * (i.e. it isn't already an exact catalog entry). Exported for unit tests.
+ */
+export declare function resolveStoredViewRef(views: Array<{
+    name: string;
+    label?: string;
+}>, current: string): {
+    exact?: {
+        name: string;
+        label?: string;
+    };
+    suffixMatch?: {
+        name: string;
+        label?: string;
+    };
+    isSpecial: boolean;
+    resolves: boolean;
+    showStored: boolean;
+};
+/**
+ * Searchable icon picker for `widget: 'icon'` string fields (page/app/object
+ * `icon`). Replaces the raw text input where an author had to know and type a
+ * Lucide name. The trigger shows a live preview of the current icon; opening it
+ * reveals a search box + a grid of matching icons (preview + name). Selecting
+ * writes the kebab-case name string.
+ *
+ * Out-of-catalog values survive: a name that isn't a Lucide icon (e.g. one from
+ * another library, or a typo to be fixed later) is still shown on the trigger as
+ * plain text (LazyIcon degrades to a fallback glyph) and is offered as the first
+ * "keep" option so re-opening the picker never silently drops it.
+ *
+ * Built inline (no Radix portal) so the search + grid render eagerly — the same
+ * jsdom-friendly choice the other pickers' tests rely on.
+ */
+export declare function IconPickerWidget({ id, value, onChange, readOnly }: WidgetProps): React.JSX.Element;
+/** Mirrors objectql\'s SECRET_MASK: a stored secret reads back as this, never plaintext. */
+export declare const SECRET_MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
 export declare const WIDGETS: Record<string, WidgetRenderer>;
-export declare function CodeWidget({ schema, value, onChange, readOnly, fieldSpec, }: WidgetProps): import("react/jsx-runtime").JSX.Element;
+export declare function CodeWidget({ schema, value, onChange, readOnly, fieldSpec, }: WidgetProps): React.JSX.Element;