@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/views/metadata-admin/previews/useFlowNodePalette.d.ts

@@ -0,0 +1,44 @@
+import { type PaletteItem } from './flow-canvas-parts';
+/** Minimal shape of an engine action descriptor we consume. */
+interface ActionDescriptorLite {
+    type: string;
+    name?: string;
+    description?: string;
+    paradigms?: string[];
+    deprecated?: boolean;
+    /**
+     * JSON Schema for the node's `config` (ADR-0018 §configSchema). Present only
+     * for actions whose executor publishes one (e.g. the ADR-0019 approval node).
+     * Drives the inspector's server-rendered property form.
+     */
+    configSchema?: unknown;
+}
+/** Server API base — shared by the palette fetch and the runs panel. */
+export declare function apiBase(): string;
+/**
+ * Merge engine descriptors onto the hardcoded base. Base order is canonical;
+ * a descriptor overlays its base entry's label/hint (so the engine is the
+ * source of truth for naming), and engine-only types are appended.
+ */
+export declare function mergePalette(base: PaletteItem[], descriptors: ActionDescriptorLite[]): PaletteItem[];
+/**
+ * Fetch the running engine's published action descriptors from
+ * `GET /api/v1/automation/actions`. Returns `[]` while loading or on any error
+ * (offline / plugin absent / older backend), so consumers fall back to their
+ * hardcoded defaults. Shared by both the palette and the inspector's
+ * server-driven config form.
+ */
+export declare function useActionDescriptors(): ActionDescriptorLite[];
+/**
+ * Returns the node palette merged with the running engine's published
+ * descriptors. Falls back to {@link NODE_PALETTE} while loading or on any
+ * error, so the designer always has a usable palette.
+ */
+export declare function useFlowNodePalette(): PaletteItem[];
+/**
+ * Map of node `type` → published config JSON Schema, for the actions whose
+ * executor publishes one. Empty while loading / offline, so the inspector
+ * falls back to its hardcoded field group for every type.
+ */
+export declare function useActionConfigSchemas(): Record<string, unknown>;
+export {};

package/dist/views/metadata-admin/previews/useFlowNodePalette.js

@@ -0,0 +1,124 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * useFlowNodePalette — server-driven node palette for the flow designer.
+ *
+ * The set of node types a flow can use is owned by the automation **engine**,
+ * not the client: built-in node packs and plugins (e.g. the ADR-0019
+ * `approval` node contributed by the approvals plugin, or third-party
+ * `connector_action` providers) publish an `ActionDescriptor` that the engine
+ * exposes at `GET /api/v1/automation/actions` — the same registry that backs
+ * server-side flow validation. Driving the palette from that endpoint keeps the
+ * designer in lock-step with what the running backend actually supports.
+ *
+ * The hardcoded {@link NODE_PALETTE} stays as the base: it supplies the
+ * structural / control nodes the engine does not publish as actions (subflow,
+ * wait, end, connector_action) and acts as an offline fallback so the designer
+ * still works when the endpoint is unreachable or the plugin is not installed.
+ * Server descriptors are overlaid on top — keeping the base ordering, adopting
+ * the engine's labels/descriptions, and appending any engine-only node types
+ * (and future plugin nodes) the base doesn't list.
+ */
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { NODE_PALETTE, nodeCategory } from './flow-canvas-parts';
+/** Server API base — shared by the palette fetch and the runs panel. */
+export function apiBase() {
+    const url = import.meta.env?.VITE_SERVER_URL || '';
+    return `${String(url).replace(/\/$/, '')}/api/v1`;
+}
+/**
+ * Merge engine descriptors onto the hardcoded base. Base order is canonical;
+ * a descriptor overlays its base entry's label/hint (so the engine is the
+ * source of truth for naming), and engine-only types are appended.
+ */
+export function mergePalette(base, descriptors) {
+    const byType = new Map();
+    for (const item of base)
+        byType.set(item.type, item);
+    for (const d of descriptors) {
+        if (!d?.type)
+            continue;
+        if (d.deprecated)
+            continue;
+        // The flow designer only offers flow-capable nodes. Descriptors without a
+        // paradigm list are treated as flow-capable (conservative default).
+        if (Array.isArray(d.paradigms) && d.paradigms.length > 0 && !d.paradigms.includes('flow'))
+            continue;
+        const existing = byType.get(d.type);
+        byType.set(d.type, {
+            type: d.type,
+            label: d.name || existing?.label || d.type,
+            hint: d.description || existing?.hint,
+            // Keep the base item's section; infer one for engine-only/plugin types so
+            // they still group sensibly in the palette.
+            category: existing?.category ?? nodeCategory(d.type),
+        });
+    }
+    return [...byType.values()];
+}
+/**
+ * Fetch the running engine's published action descriptors from
+ * `GET /api/v1/automation/actions`. Returns `[]` while loading or on any error
+ * (offline / plugin absent / older backend), so consumers fall back to their
+ * hardcoded defaults. Shared by both the palette and the inspector's
+ * server-driven config form.
+ */
+export function useActionDescriptors() {
+    const [descriptors, setDescriptors] = useState([]);
+    // Avoid a state update after unmount (the fetch resolves async).
+    const alive = useRef(true);
+    useEffect(() => {
+        alive.current = true;
+        const controller = new AbortController();
+        (async () => {
+            try {
+                const res = await fetch(`${apiBase()}/automation/actions`, {
+                    credentials: 'include',
+                    headers: { 'Content-Type': 'application/json' },
+                    signal: controller.signal,
+                });
+                if (!res.ok)
+                    return; // keep fallbacks (404/501 when plugin absent)
+                const payload = (await res.json());
+                const actions = payload?.data?.actions;
+                if (!Array.isArray(actions) || actions.length === 0)
+                    return;
+                if (alive.current)
+                    setDescriptors(actions);
+            }
+            catch {
+                /* offline / aborted — keep the hardcoded fallback */
+            }
+        })();
+        return () => {
+            alive.current = false;
+            controller.abort();
+        };
+    }, []);
+    return descriptors;
+}
+/**
+ * Returns the node palette merged with the running engine's published
+ * descriptors. Falls back to {@link NODE_PALETTE} while loading or on any
+ * error, so the designer always has a usable palette.
+ */
+export function useFlowNodePalette() {
+    const descriptors = useActionDescriptors();
+    return useMemo(() => (descriptors.length ? mergePalette(NODE_PALETTE, descriptors) : NODE_PALETTE), [descriptors]);
+}
+/**
+ * Map of node `type` → published config JSON Schema, for the actions whose
+ * executor publishes one. Empty while loading / offline, so the inspector
+ * falls back to its hardcoded field group for every type.
+ */
+export function useActionConfigSchemas() {
+    const descriptors = useActionDescriptors();
+    return useMemo(() => {
+        const map = {};
+        for (const d of descriptors) {
+            if (d?.type && d.configSchema !== undefined && d.configSchema !== null) {
+                map[d.type] = d.configSchema;
+            }
+        }
+        return map;
+    }, [descriptors]);
+}

package/dist/views/metadata-admin/previews/useMetaOptions.d.ts

@@ -0,0 +1,8 @@
+export interface MetaOption {
+    value: string;
+    label: string;
+}
+export declare function useMetaOptions(type: string | null): {
+    options: MetaOption[];
+    loading: boolean;
+};

package/dist/views/metadata-admin/previews/useMetaOptions.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * useMetaOptions — name+label options for ANY metadata type (generalises
+ * {@link useObjectOptions}). Powers reference pickers that point at a metadata
+ * record by name (e.g. an Action's `target` → a flow / page / view). Async;
+ * degrades to an empty list so callers fall back to a free-text input. Pass
+ * `null` to skip fetching.
+ */
+import * as React from 'react';
+import { useMetadataClient } from '../useMetadata';
+export function useMetaOptions(type) {
+    const client = useMetadataClient();
+    const [options, setOptions] = React.useState([]);
+    const [loading, setLoading] = React.useState(!!type);
+    React.useEffect(() => {
+        if (!type) {
+            setOptions([]);
+            setLoading(false);
+            return;
+        }
+        let cancelled = false;
+        setLoading(true);
+        client
+            .list(type)
+            .then((items) => {
+            if (cancelled)
+                return;
+            const mapped = (items ?? [])
+                .map((raw) => (raw && typeof raw === 'object' && 'item' in raw ? raw.item : raw))
+                .filter((i) => typeof i?.name === 'string' && i.name)
+                .map((i) => ({
+                value: i.name,
+                label: i.label ? `${i.label} (${i.name})` : i.name,
+            }))
+                .sort((a, b) => a.value.localeCompare(b.value));
+            setOptions(mapped);
+            setLoading(false);
+        })
+            .catch(() => {
+            if (!cancelled) {
+                setOptions([]);
+                setLoading(false);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client, type]);
+    return { options, loading };
+}

package/dist/views/metadata-admin/previews/useObjectFields.d.ts

@@ -0,0 +1,23 @@
+export interface ObjectFieldInfo {
+    /** snake_case API name. */
+    name: string;
+    /** Human label (falls back to the name). */
+    label: string;
+    /** Raw field type id (e.g. 'text', 'lookup'). */
+    type: string;
+    hidden: boolean;
+}
+export interface UseObjectFieldsResult {
+    fields: ObjectFieldInfo[];
+    loading: boolean;
+    error: string | null;
+}
+export declare function useObjectFields(objectName: string | undefined, 
+/**
+ * Pre-resolved field catalog. When supplied the hook skips the network
+ * fetch entirely and returns this list verbatim — used by hosts that
+ * already hold the object definition (e.g. the runtime ViewConfigPanel,
+ * which reads `objectDef.fields`) so the inspector has zero network
+ * dependency.
+ */
+override?: ObjectFieldInfo[]): UseObjectFieldsResult;

package/dist/views/metadata-admin/previews/useObjectFields.js

@@ -0,0 +1,79 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * useObjectFields — loads an Object's field catalog for the View column
+ * configurator's "Available fields" pane.
+ *
+ * Reads `object.fields` (record OR array shape) via the shared
+ * MetadataClient and normalizes it into a flat, ordered list the picker
+ * can render. Hidden fields are kept (admins legitimately surface them)
+ * but flagged so the picker can de-emphasize them.
+ *
+ * The hook is defensive: a missing object name, a 404, or a transport
+ * error all resolve to an empty list with `error` set, so the configurator
+ * can gracefully fall back to manual column entry.
+ */
+import * as React from 'react';
+import { useMetadataClient } from '../useMetadata';
+import { readFields } from './object-fields-io';
+export function useObjectFields(objectName, 
+/**
+ * Pre-resolved field catalog. When supplied the hook skips the network
+ * fetch entirely and returns this list verbatim — used by hosts that
+ * already hold the object definition (e.g. the runtime ViewConfigPanel,
+ * which reads `objectDef.fields`) so the inspector has zero network
+ * dependency.
+ */
+override) {
+    const client = useMetadataClient();
+    const [state, setState] = React.useState({
+        fields: [],
+        loading: !override && !!objectName,
+        error: null,
+    });
+    React.useEffect(() => {
+        // Override short-circuits the fetch: trust the caller-supplied catalog.
+        if (override) {
+            setState({ fields: override, loading: false, error: null });
+            return;
+        }
+        if (!objectName) {
+            setState({ fields: [], loading: false, error: null });
+            return;
+        }
+        let cancelled = false;
+        setState((s) => ({ ...s, loading: true, error: null }));
+        client
+            .get('object', objectName)
+            .then((obj) => {
+            if (cancelled)
+                return;
+            if (!obj) {
+                setState({ fields: [], loading: false, error: 'Object not found' });
+                return;
+            }
+            const view = readFields(obj.fields);
+            const fields = view.entries.map((e) => ({
+                name: e.name,
+                label: typeof e.def.label === 'string' && e.def.label
+                    ? e.def.label
+                    : e.name,
+                type: typeof e.def.type === 'string' ? e.def.type : 'text',
+                hidden: e.def.hidden === true,
+            }));
+            setState({ fields, loading: false, error: null });
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setState({
+                fields: [],
+                loading: false,
+                error: err?.message ?? String(err),
+            });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client, objectName, override]);
+    return state;
+}

package/dist/views/metadata-admin/previews/useObjectOptions.d.ts

@@ -0,0 +1,8 @@
+export interface ObjectOption {
+    value: string;
+    label: string;
+}
+export declare function useObjectOptions(): {
+    options: ObjectOption[];
+    loading: boolean;
+};

package/dist/views/metadata-admin/previews/useObjectOptions.js

@@ -0,0 +1,43 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * useObjectOptions — the list of objects (name + label) for object pickers in
+ * the page-editor block inspector. Async; degrades to an empty list (the
+ * picker then falls back to a free-text input).
+ */
+import * as React from 'react';
+import { useMetadataClient } from '../useMetadata';
+export function useObjectOptions() {
+    const client = useMetadataClient();
+    const [options, setOptions] = React.useState([]);
+    const [loading, setLoading] = React.useState(true);
+    React.useEffect(() => {
+        let cancelled = false;
+        setLoading(true);
+        client
+            .list('object')
+            .then((items) => {
+            if (cancelled)
+                return;
+            const mapped = (items ?? [])
+                .map((raw) => (raw && typeof raw === 'object' && 'item' in raw ? raw.item : raw))
+                .filter((i) => typeof i?.name === 'string' && i.name)
+                .map((i) => ({
+                value: i.name,
+                label: i.label ? `${i.label} (${i.name})` : i.name,
+            }))
+                .sort((a, b) => a.value.localeCompare(b.value));
+            setOptions(mapped);
+            setLoading(false);
+        })
+            .catch(() => {
+            if (!cancelled) {
+                setOptions([]);
+                setLoading(false);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client]);
+    return { options, loading };
+}

package/dist/views/metadata-admin/previews/view-column-io.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Column-IO helpers for the View column configurator.
+ *
+ * A View variant's `columns` array holds entries in one of two
+ * canonical shapes:
+ *   • `string`                       — bare field name (kanban-style)
+ *   • `{ field, label, ... }`        — ObjectStack canonical shape
+ *   • `{ accessorKey, header, ... }` — legacy/imported TanStack shape
+ *
+ * These helpers read either shape without mutating it and build new
+ * entries that respect a variant's all-strings invariant so round-trips
+ * stay lossless.
+ */
+export interface VariantInfo {
+    key: string;
+    schema: Record<string, unknown>;
+    columns: unknown[];
+    allStrings: boolean;
+}
+/** Human label for a column entry (falls back to a positional label). */
+export declare function colLabel(c: unknown, i: number): string;
+/** Bound field name for a column entry, if any. */
+export declare function colFieldName(c: unknown): string | undefined;
+/** Set of field names already used as columns in a variant. */
+export declare function usedFieldNames(columns: unknown[]): Set<string>;
+/**
+ * Build a fresh column entry for `fieldName`. Honors the variant's
+ * all-strings invariant: string variants get a bare field name, object
+ * variants get `{ field, label }`.
+ */
+export declare function makeColumn(allStrings: boolean, fieldName: string, label?: string): unknown;
+/**
+ * Remap a selected column index after a remove at `removedIndex`.
+ * Returns the new index, or `null` when the selected column itself was
+ * removed (caller should clear the selection).
+ */
+export declare function remapIndexAfterRemove(selectedIndex: number, removedIndex: number): number | null;
+/**
+ * Remap a selected column index after a move from `from` to `to`.
+ * Mirrors `moveArray` semantics (remove-then-insert on the same list).
+ */
+export declare function remapIndexAfterMove(selectedIndex: number, from: number, to: number): number;

package/dist/views/metadata-admin/previews/view-column-io.js

@@ -0,0 +1,73 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/** Human label for a column entry (falls back to a positional label). */
+export function colLabel(c, i) {
+    if (typeof c === 'string')
+        return c || `col ${i + 1}`;
+    if (c && typeof c === 'object') {
+        const o = c;
+        return String(o.label ?? o.header ?? o.field ?? o.accessorKey ?? `col ${i + 1}`);
+    }
+    return `col ${i + 1}`;
+}
+/** Bound field name for a column entry, if any. */
+export function colFieldName(c) {
+    if (typeof c === 'string')
+        return c || undefined;
+    if (c && typeof c === 'object') {
+        const o = c;
+        const v = o.field ?? o.accessorKey;
+        return typeof v === 'string' && v ? v : undefined;
+    }
+    return undefined;
+}
+/** Set of field names already used as columns in a variant. */
+export function usedFieldNames(columns) {
+    const out = new Set();
+    for (const c of columns) {
+        const f = colFieldName(c);
+        if (f)
+            out.add(f);
+    }
+    return out;
+}
+/**
+ * Build a fresh column entry for `fieldName`. Honors the variant's
+ * all-strings invariant: string variants get a bare field name, object
+ * variants get `{ field, label }`.
+ */
+export function makeColumn(allStrings, fieldName, label) {
+    if (allStrings)
+        return fieldName;
+    const col = { field: fieldName };
+    if (label && label !== fieldName)
+        col.label = label;
+    return col;
+}
+/**
+ * Remap a selected column index after a remove at `removedIndex`.
+ * Returns the new index, or `null` when the selected column itself was
+ * removed (caller should clear the selection).
+ */
+export function remapIndexAfterRemove(selectedIndex, removedIndex) {
+    if (selectedIndex === removedIndex)
+        return null;
+    if (selectedIndex > removedIndex)
+        return selectedIndex - 1;
+    return selectedIndex;
+}
+/**
+ * Remap a selected column index after a move from `from` to `to`.
+ * Mirrors `moveArray` semantics (remove-then-insert on the same list).
+ */
+export function remapIndexAfterMove(selectedIndex, from, to) {
+    if (selectedIndex === from)
+        return to;
+    // The moved item left `from` and was inserted at `to`; indices between
+    // shift by one in the appropriate direction.
+    let idx = selectedIndex;
+    if (from < idx)
+        idx -= 1;
+    if (to <= idx)
+        idx += 1;
+    return idx;
+}

package/dist/views/metadata-admin/previews/widget-types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Catalog of Dashboard widget types — the same set @objectstack/spec
+ * publishes for `DashboardWidgetSchema.type`. Used by the Dashboard
+ * designer's "Add widget" picker so authors can choose a chart kind
+ * up front instead of always starting from `metric` and rebinding.
+ */
+import { type LucideIcon } from 'lucide-react';
+export type WidgetCategory = 'kpi' | 'chart' | 'data' | 'custom';
+export interface WidgetTypeMeta {
+    id: string;
+    label: string;
+    category: WidgetCategory;
+    icon: LucideIcon;
+    /** Sensible defaults applied when this widget is added. */
+    defaults?: Record<string, unknown>;
+}
+export declare const WIDGET_TYPE_META: Record<string, WidgetTypeMeta>;
+export declare const WIDGET_CATEGORY_LABEL: Record<WidgetCategory, string>;
+export declare const WIDGETS_BY_CATEGORY: Array<{
+    category: WidgetCategory;
+    types: WidgetTypeMeta[];
+}>;
+export declare const UnknownWidgetIcon: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+export declare const FilterIcon: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;

package/dist/views/metadata-admin/previews/widget-types.js

@@ -0,0 +1,40 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * Catalog of Dashboard widget types — the same set @objectstack/spec
+ * publishes for `DashboardWidgetSchema.type`. Used by the Dashboard
+ * designer's "Add widget" picker so authors can choose a chart kind
+ * up front instead of always starting from `metric` and rebinding.
+ */
+import { Activity, AreaChart, BarChart, BarChart2, Code2, Database, Donut, Filter, Hash, LineChart, List, PieChart, ScatterChart, Table2, TrendingDown, } from 'lucide-react';
+export const WIDGET_TYPE_META = {
+    metric: { id: 'metric', label: 'Metric (KPI)', category: 'kpi', icon: Hash },
+    bar: { id: 'bar', label: 'Bar chart', category: 'chart', icon: BarChart },
+    'horizontal-bar': {
+        id: 'horizontal-bar',
+        label: 'Horizontal bar',
+        category: 'chart',
+        icon: BarChart2,
+    },
+    line: { id: 'line', label: 'Line chart', category: 'chart', icon: LineChart },
+    area: { id: 'area', label: 'Area chart', category: 'chart', icon: AreaChart },
+    pie: { id: 'pie', label: 'Pie chart', category: 'chart', icon: PieChart },
+    donut: { id: 'donut', label: 'Donut chart', category: 'chart', icon: Donut },
+    scatter: { id: 'scatter', label: 'Scatter plot', category: 'chart', icon: ScatterChart },
+    funnel: { id: 'funnel', label: 'Funnel', category: 'chart', icon: TrendingDown },
+    table: { id: 'table', label: 'Data table', category: 'data', icon: Table2 },
+    pivot: { id: 'pivot', label: 'Pivot table', category: 'data', icon: Database },
+    list: { id: 'list', label: 'Record list', category: 'data', icon: List },
+    custom: { id: 'custom', label: 'Custom widget', category: 'custom', icon: Code2 },
+};
+export const WIDGET_CATEGORY_LABEL = {
+    kpi: 'Single value',
+    chart: 'Charts',
+    data: 'Tabular',
+    custom: 'Custom',
+};
+export const WIDGETS_BY_CATEGORY = ['kpi', 'chart', 'data', 'custom'].map((category) => ({
+    category,
+    types: Object.values(WIDGET_TYPE_META).filter((m) => m.category === category),
+}));
+export const UnknownWidgetIcon = Activity;
+export const FilterIcon = Filter;