@object-ui/react 3.0.2 → 3.1.0

package/dist/spec-bridge/bridges/dashboard.d.ts

@@ -0,0 +1,81 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { BridgeFn } from '../types';
+interface DashboardWidget {
+    title?: string;
+    description?: string;
+    type?: string;
+    chartConfig?: any;
+    colorVariant?: string;
+    actionUrl?: string;
+    actionType?: string;
+    actionIcon?: string;
+    object?: string;
+    filter?: any;
+    categoryField?: string;
+    valueField?: string;
+    aggregate?: string;
+    measures?: any[];
+    layout?: any;
+    options?: any;
+    responsive?: any;
+    aria?: {
+        ariaLabel?: string;
+        ariaDescribedBy?: string;
+        role?: string;
+    };
+}
+interface DashboardHeader {
+    showTitle?: boolean;
+    showDescription?: boolean;
+    actions?: Array<{
+        label: string;
+        actionUrl?: string;
+        actionType?: string;
+        icon?: string;
+    }>;
+    [key: string]: any;
+}
+interface GlobalFilter {
+    field: string;
+    label?: string;
+    type?: string;
+    options?: string[];
+    optionsFrom?: {
+        object: string;
+        valueField: string;
+        labelField?: string;
+        filter?: any;
+    };
+    defaultValue?: any;
+    scope?: string;
+    targetWidgets?: string[];
+}
+interface DashboardSpec {
+    name?: string;
+    label?: string;
+    description?: string;
+    widgets?: DashboardWidget[];
+    globalFilters?: GlobalFilter[];
+    header?: DashboardHeader;
+    refreshInterval?: number;
+    dateRange?: {
+        field?: string;
+        defaultRange?: string;
+        allowCustomRange?: boolean;
+    };
+    aria?: {
+        ariaLabel?: string;
+        ariaDescribedBy?: string;
+        role?: string;
+    };
+    performance?: any;
+}
+/** Transforms a Dashboard spec into a dashboard layout SchemaNode */
+export declare const bridgeDashboard: BridgeFn<DashboardSpec>;
+export {};

package/dist/spec-bridge/bridges/dashboard.js

@@ -0,0 +1,121 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function mapWidget(widget, index) {
+    const node = {
+        type: widget.type ?? 'chart',
+        id: `widget-${index}`,
+    };
+    if (widget.title)
+        node.title = widget.title;
+    if (widget.description)
+        node.description = widget.description;
+    if (widget.chartConfig)
+        node.chartConfig = widget.chartConfig;
+    if (widget.colorVariant)
+        node.colorVariant = widget.colorVariant;
+    if (widget.actionUrl)
+        node.actionUrl = widget.actionUrl;
+    if (widget.actionType)
+        node.actionType = widget.actionType;
+    if (widget.actionIcon)
+        node.actionIcon = widget.actionIcon;
+    if (widget.object)
+        node.object = widget.object;
+    if (widget.filter)
+        node.filter = widget.filter;
+    if (widget.categoryField)
+        node.categoryField = widget.categoryField;
+    if (widget.valueField)
+        node.valueField = widget.valueField;
+    if (widget.aggregate)
+        node.aggregate = widget.aggregate;
+    if (widget.measures)
+        node.measures = widget.measures;
+    if (widget.layout)
+        node.layout = widget.layout;
+    if (widget.options)
+        node.options = widget.options;
+    if (widget.responsive)
+        node.responsive = widget.responsive;
+    if (widget.aria)
+        node.aria = widget.aria;
+    return node;
+}
+function mapGlobalFilters(filters) {
+    return {
+        type: 'filter-bar',
+        id: 'dashboard-filters',
+        filters: filters.map((f) => {
+            const mapped = { field: f.field };
+            if (f.label)
+                mapped.label = f.label;
+            if (f.type)
+                mapped.type = f.type;
+            if (f.options)
+                mapped.options = f.options;
+            if (f.optionsFrom)
+                mapped.optionsFrom = f.optionsFrom;
+            if (f.defaultValue != null)
+                mapped.defaultValue = f.defaultValue;
+            if (f.scope)
+                mapped.scope = f.scope;
+            if (f.targetWidgets)
+                mapped.targetWidgets = f.targetWidgets;
+            return mapped;
+        }),
+    };
+}
+function mapHeader(header) {
+    const node = {
+        type: 'dashboard-header',
+        id: 'dashboard-header',
+        ...header,
+    };
+    return node;
+}
+/** Transforms a Dashboard spec into a dashboard layout SchemaNode */
+export const bridgeDashboard = (spec, _context) => {
+    const widgetNodes = (spec.widgets ?? []).map(mapWidget);
+    const bodyChildren = [];
+    if (spec.header) {
+        bodyChildren.push(mapHeader(spec.header));
+    }
+    if (spec.globalFilters && spec.globalFilters.length > 0) {
+        bodyChildren.push(mapGlobalFilters(spec.globalFilters));
+    }
+    // P1.3 — Date range filter
+    if (spec.dateRange) {
+        bodyChildren.push({
+            type: 'date-range-filter',
+            id: 'dashboard-date-range',
+            ...spec.dateRange,
+        });
+    }
+    bodyChildren.push({
+        type: 'widget-grid',
+        id: 'dashboard-widgets',
+        body: widgetNodes,
+    });
+    const node = {
+        type: 'dashboard',
+        id: spec.name,
+        body: bodyChildren,
+    };
+    if (spec.label)
+        node.label = spec.label;
+    if (spec.description)
+        node.description = spec.description;
+    if (spec.refreshInterval != null)
+        node.refreshInterval = spec.refreshInterval;
+    // P1.6 — i18n & ARIA
+    if (spec.aria)
+        node.aria = spec.aria;
+    if (spec.performance)
+        node.performance = spec.performance;
+    return node;
+};

package/dist/spec-bridge/bridges/form-view.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { BridgeFn } from '../types';
+interface FormField {
+    field: string;
+    label?: string;
+    placeholder?: string;
+    helpText?: string;
+    readonly?: boolean;
+    required?: boolean;
+    hidden?: boolean;
+    colSpan?: number;
+    widget?: string;
+    dependsOn?: string[];
+    visibleOn?: string;
+}
+interface FormSection {
+    label?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    columns?: number;
+    fields?: FormField[];
+}
+interface FormViewSpec {
+    type?: string;
+    data?: any;
+    sections?: FormSection[];
+    groups?: any;
+    defaultSort?: any;
+    sharing?: any;
+    aria?: {
+        ariaLabel?: string;
+        ariaDescribedBy?: string;
+        role?: string;
+    };
+}
+/** Transforms a FormView spec into a Form SchemaNode */
+export declare const bridgeFormView: BridgeFn<FormViewSpec>;
+export {};

package/dist/spec-bridge/bridges/form-view.js

@@ -0,0 +1,77 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function mapField(field) {
+    const mapped = {
+        name: field.field,
+        label: field.label ?? field.field,
+    };
+    if (field.placeholder)
+        mapped.placeholder = field.placeholder;
+    if (field.helpText)
+        mapped.helpText = field.helpText;
+    if (field.readonly != null)
+        mapped.readonly = field.readonly;
+    if (field.required != null)
+        mapped.required = field.required;
+    if (field.hidden != null)
+        mapped.hidden = field.hidden;
+    if (field.colSpan != null)
+        mapped.colSpan = field.colSpan;
+    if (field.widget)
+        mapped.widget = field.widget;
+    if (field.dependsOn)
+        mapped.dependsOn = field.dependsOn;
+    if (field.visibleOn)
+        mapped.visibleOn = field.visibleOn;
+    return mapped;
+}
+function mapSection(section) {
+    const mapped = {
+        fields: (section.fields ?? []).map(mapField),
+    };
+    if (section.label)
+        mapped.label = section.label;
+    if (section.collapsible != null)
+        mapped.collapsible = section.collapsible;
+    if (section.collapsed != null)
+        mapped.collapsed = section.collapsed;
+    if (section.columns != null)
+        mapped.columns = section.columns;
+    return mapped;
+}
+/** Maps spec formType to ObjectUI formType */
+function mapFormType(type) {
+    if (!type)
+        return undefined;
+    const validTypes = ['simple', 'tabbed', 'wizard', 'split', 'drawer', 'modal'];
+    return validTypes.includes(type) ? type : undefined;
+}
+/** Transforms a FormView spec into a Form SchemaNode */
+export const bridgeFormView = (spec, _context) => {
+    const sections = (spec.sections ?? []).map(mapSection);
+    const formType = mapFormType(spec.type);
+    const node = {
+        type: 'object-form',
+        id: `form-${spec.type ?? 'default'}`,
+        sections,
+        data: spec.data,
+    };
+    // P1.2 — formType mapping (tabbed, wizard, split, drawer, modal)
+    if (formType)
+        node.formType = formType;
+    if (spec.groups)
+        node.groups = spec.groups;
+    if (spec.defaultSort)
+        node.defaultSort = spec.defaultSort;
+    // P1.6 — i18n & ARIA
+    if (spec.sharing)
+        node.sharing = spec.sharing;
+    if (spec.aria)
+        node.aria = spec.aria;
+    return node;
+};

package/dist/spec-bridge/bridges/list-view.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { BridgeFn } from '../types';
+import type { ListViewGalleryConfig, ListViewTimelineConfig } from '@object-ui/types';
+interface ListColumn {
+    field: string;
+    label?: string;
+    width?: number;
+    align?: string;
+    hidden?: boolean;
+    sortable?: boolean;
+    resizable?: boolean;
+    wrap?: boolean;
+    type?: string;
+    pinned?: string;
+    summary?: any;
+    link?: any;
+    action?: any;
+}
+interface ListViewSpec {
+    name?: string;
+    label?: string;
+    type?: string;
+    data?: any;
+    columns?: ListColumn[];
+    filter?: any;
+    sort?: any;
+    searchableFields?: string[];
+    filterableFields?: string[];
+    quickFilters?: any[];
+    selection?: any;
+    pagination?: any;
+    rowHeight?: string;
+    resizable?: boolean;
+    striped?: boolean;
+    bordered?: boolean;
+    grouping?: any;
+    rowColor?: any;
+    navigation?: any;
+    kanban?: any;
+    calendar?: any;
+    gantt?: any;
+    gallery?: ListViewGalleryConfig;
+    timeline?: ListViewTimelineConfig;
+    rowActions?: string[];
+    bulkActions?: string[];
+    virtualScroll?: boolean;
+    conditionalFormatting?: Array<{
+        condition: string;
+        style: Record<string, string>;
+    }>;
+    inlineEdit?: boolean;
+    exportOptions?: any;
+    emptyState?: {
+        title?: string;
+        message?: string;
+        icon?: string;
+    };
+    userActions?: any;
+    appearance?: any;
+    tabs?: any[];
+    addRecord?: any;
+    showRecordCount?: boolean;
+    allowPrinting?: boolean;
+    aria?: {
+        ariaLabel?: string;
+        ariaDescribedBy?: string;
+        role?: string;
+    };
+    sharing?: any;
+    hiddenFields?: string[];
+    fieldOrder?: string[];
+    description?: string;
+}
+/** Transforms a ListView spec into a DataTable SchemaNode */
+export declare const bridgeListView: BridgeFn<ListViewSpec>;
+export {};

package/dist/spec-bridge/bridges/list-view.js

@@ -0,0 +1,154 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { normalizeQuickFilters } from '@object-ui/core';
+function mapColumn(col) {
+    const mapped = {
+        accessorKey: col.field,
+        header: col.label ?? col.field,
+    };
+    if (col.width != null)
+        mapped.width = col.width;
+    if (col.align)
+        mapped.align = col.align;
+    if (col.hidden != null)
+        mapped.hidden = col.hidden;
+    if (col.sortable != null)
+        mapped.sortable = col.sortable;
+    if (col.resizable != null)
+        mapped.resizable = col.resizable;
+    if (col.wrap != null)
+        mapped.wrap = col.wrap;
+    if (col.type)
+        mapped.type = col.type;
+    if (col.pinned)
+        mapped.pinned = col.pinned;
+    if (col.summary)
+        mapped.summary = col.summary;
+    if (col.link)
+        mapped.link = col.link;
+    if (col.action)
+        mapped.action = col.action;
+    return mapped;
+}
+function mapDensity(rowHeight) {
+    if (!rowHeight)
+        return undefined;
+    const map = {
+        compact: 'compact',
+        short: 'compact',
+        comfortable: 'comfortable',
+        spacious: 'spacious',
+        small: 'compact',
+        medium: 'comfortable',
+        large: 'spacious',
+        tall: 'spacious',
+        extra_tall: 'spacious',
+    };
+    return map[rowHeight];
+}
+/** Transforms a ListView spec into a DataTable SchemaNode */
+export const bridgeListView = (spec, _context) => {
+    const columns = (spec.columns ?? []).map(mapColumn);
+    const density = mapDensity(spec.rowHeight);
+    const node = {
+        type: 'object-grid',
+        id: spec.name,
+        columns,
+        data: spec.data,
+    };
+    if (spec.label)
+        node.label = spec.label;
+    if (spec.selection)
+        node.selection = spec.selection;
+    if (spec.pagination)
+        node.pagination = spec.pagination;
+    if (spec.sort)
+        node.sort = spec.sort;
+    if (spec.filter)
+        node.filter = spec.filter;
+    if (density)
+        node.density = density;
+    if (spec.grouping)
+        node.grouping = spec.grouping;
+    if (spec.rowColor)
+        node.rowColor = spec.rowColor;
+    if (spec.searchableFields)
+        node.searchableFields = spec.searchableFields;
+    if (spec.filterableFields)
+        node.filterableFields = spec.filterableFields;
+    // Normalize quickFilters: spec format { field, operator, value } → ObjectUI format
+    const normalizedQF = normalizeQuickFilters(spec.quickFilters);
+    if (normalizedQF)
+        node.quickFilters = normalizedQF;
+    if (spec.resizable != null)
+        node.resizable = spec.resizable;
+    if (spec.striped != null)
+        node.striped = spec.striped;
+    if (spec.bordered != null)
+        node.bordered = spec.bordered;
+    if (spec.navigation)
+        node.navigation = spec.navigation;
+    if (spec.kanban)
+        node.kanban = spec.kanban;
+    if (spec.calendar)
+        node.calendar = spec.calendar;
+    if (spec.gantt)
+        node.gantt = spec.gantt;
+    if (spec.gallery)
+        node.gallery = spec.gallery;
+    if (spec.timeline)
+        node.timeline = spec.timeline;
+    // P1.1 — Spec Protocol Alignment additions
+    if (spec.rowActions)
+        node.rowActions = spec.rowActions;
+    if (spec.bulkActions)
+        node.bulkActions = spec.bulkActions;
+    if (spec.virtualScroll != null)
+        node.virtualScroll = spec.virtualScroll;
+    if (spec.conditionalFormatting)
+        node.conditionalFormatting = spec.conditionalFormatting;
+    if (spec.inlineEdit != null)
+        node.inlineEdit = spec.inlineEdit;
+    if (spec.exportOptions)
+        node.exportOptions = spec.exportOptions;
+    if (spec.emptyState)
+        node.emptyState = spec.emptyState;
+    if (spec.userActions)
+        node.userActions = spec.userActions;
+    if (spec.appearance)
+        node.appearance = spec.appearance;
+    if (spec.tabs)
+        node.tabs = spec.tabs;
+    if (spec.addRecord)
+        node.addRecord = spec.addRecord;
+    if (spec.showRecordCount != null)
+        node.showRecordCount = spec.showRecordCount;
+    if (spec.allowPrinting != null)
+        node.allowPrinting = spec.allowPrinting;
+    // P1.6 — i18n & ARIA
+    if (spec.aria)
+        node.aria = spec.aria;
+    if (spec.sharing) {
+        // Normalize spec sharing format: map type → visibility, set enabled = true
+        const sharing = { ...spec.sharing };
+        if (sharing.type && !sharing.visibility) {
+            sharing.visibility = sharing.type === 'collaborative' ? 'team' : 'private';
+        }
+        if (sharing.type && sharing.enabled == null) {
+            sharing.enabled = true;
+        }
+        node.sharing = sharing;
+    }
+    if (spec.hiddenFields)
+        node.hiddenFields = spec.hiddenFields;
+    if (spec.fieldOrder)
+        node.fieldOrder = spec.fieldOrder;
+    if (spec.description)
+        node.description = spec.description;
+    return node;
+};

package/dist/spec-bridge/bridges/page.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { BridgeFn } from '../types';
+interface PageComponent {
+    type: string;
+    id?: string;
+    label?: string;
+    properties?: Record<string, any>;
+    events?: Record<string, any>;
+    style?: Record<string, any>;
+    className?: string;
+    visibility?: string;
+    dataSource?: any;
+    responsive?: any;
+    aria?: Record<string, string>;
+}
+interface PageRegion {
+    name?: string;
+    width?: string;
+    components?: PageComponent[];
+}
+interface PageVariable {
+    name: string;
+    type?: string;
+    defaultValue?: any;
+    source?: string;
+}
+interface BlankPageLayoutItem {
+    componentId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface PageSpec {
+    name?: string;
+    label?: string;
+    description?: string;
+    icon?: string;
+    type?: string;
+    variables?: PageVariable[];
+    regions?: PageRegion[];
+    template?: string;
+    object?: string;
+    blankLayout?: {
+        columns?: number;
+        rowHeight?: number;
+        gap?: number;
+        items?: BlankPageLayoutItem[];
+    };
+    recordReview?: any;
+    isDefault?: boolean;
+    assignedProfiles?: string[];
+    interfaceConfig?: any;
+    aria?: {
+        ariaLabel?: string;
+        ariaDescribedBy?: string;
+        role?: string;
+    };
+}
+/** Transforms a Page spec into a page layout SchemaNode */
+export declare const bridgePage: BridgeFn<PageSpec>;
+export {};

package/dist/spec-bridge/bridges/page.js

@@ -0,0 +1,81 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function mapComponent(component) {
+    const node = {
+        type: component.type,
+        id: component.id,
+    };
+    if (component.label)
+        node.label = component.label;
+    if (component.className)
+        node.className = component.className;
+    if (component.properties) {
+        Object.assign(node, component.properties);
+    }
+    if (component.events)
+        node.events = component.events;
+    if (component.visibility)
+        node.visibility = component.visibility;
+    if (component.dataSource)
+        node.dataSource = component.dataSource;
+    if (component.responsive)
+        node.responsive = component.responsive;
+    if (component.aria)
+        node.aria = component.aria;
+    return node;
+}
+function mapRegion(region) {
+    const children = (region.components ?? []).map(mapComponent);
+    const node = {
+        type: 'page-region',
+        id: region.name,
+        body: children,
+    };
+    if (region.width)
+        node.width = region.width;
+    return node;
+}
+/** Transforms a Page spec into a page layout SchemaNode */
+export const bridgePage = (spec, _context) => {
+    const regions = (spec.regions ?? []).map(mapRegion);
+    const node = {
+        type: 'page',
+        id: spec.name,
+        body: regions,
+    };
+    if (spec.label)
+        node.label = spec.label;
+    if (spec.description)
+        node.description = spec.description;
+    if (spec.icon)
+        node.icon = spec.icon;
+    if (spec.type)
+        node.pageType = spec.type;
+    if (spec.variables)
+        node.variables = spec.variables;
+    if (spec.template)
+        node.template = spec.template;
+    if (spec.object)
+        node.object = spec.object;
+    // P1.4 — Blank page layout
+    if (spec.blankLayout)
+        node.blankLayout = spec.blankLayout;
+    // P1.4 — Additional page properties
+    if (spec.recordReview)
+        node.recordReview = spec.recordReview;
+    if (spec.isDefault != null)
+        node.isDefault = spec.isDefault;
+    if (spec.assignedProfiles)
+        node.assignedProfiles = spec.assignedProfiles;
+    if (spec.interfaceConfig)
+        node.interfaceConfig = spec.interfaceConfig;
+    // P1.6 — i18n & ARIA
+    if (spec.aria)
+        node.aria = spec.aria;
+    return node;
+};