@object-ui/core 3.1.5 → 3.3.1

package/src/types/index.ts

@@ -1,21 +0,0 @@
-/**
- * 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.
- */
-
-export interface SchemaNode {
-  type: string;
-  id?: string;
-  className?: string;
-  data?: any;
-  body?: SchemaNode | SchemaNode[];
-  [key: string]: any;
-}
-
-export interface ComponentRendererProps {
-  schema: SchemaNode;
-  [key: string]: any;
-}

package/src/utils/__tests__/debug-collector.test.ts

@@ -1,102 +0,0 @@
-/**
- * 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 { describe, it, expect, vi, beforeEach } from 'vitest';
-import { DebugCollector } from '../debug-collector';
-
-describe('DebugCollector', () => {
-  beforeEach(() => {
-    DebugCollector.resetInstance();
-  });
-
-  it('should return a singleton instance', () => {
-    const a = DebugCollector.getInstance();
-    const b = DebugCollector.getInstance();
-    expect(a).toBe(b);
-  });
-
-  it('should collect perf entries', () => {
-    const collector = DebugCollector.getInstance();
-    collector.addPerf({ type: 'button', id: 'btn1', durationMs: 5.2, timestamp: Date.now() });
-    const entries = collector.getEntries('perf');
-    expect(entries).toHaveLength(1);
-    expect(entries[0].kind).toBe('perf');
-    expect((entries[0].data as any).type).toBe('button');
-  });
-
-  it('should collect expr entries', () => {
-    const collector = DebugCollector.getInstance();
-    collector.addExpr({ expression: '${data.x > 1}', result: true, timestamp: Date.now() });
-    const entries = collector.getEntries('expr');
-    expect(entries).toHaveLength(1);
-    expect(entries[0].kind).toBe('expr');
-    expect((entries[0].data as any).result).toBe(true);
-  });
-
-  it('should collect event entries', () => {
-    const collector = DebugCollector.getInstance();
-    collector.addEvent({ action: 'navigate', payload: { to: '/home' }, timestamp: Date.now() });
-    const entries = collector.getEntries('event');
-    expect(entries).toHaveLength(1);
-    expect(entries[0].kind).toBe('event');
-    expect((entries[0].data as any).action).toBe('navigate');
-  });
-
-  it('should return all entries when no kind filter', () => {
-    const collector = DebugCollector.getInstance();
-    collector.addPerf({ type: 'text', durationMs: 1, timestamp: Date.now() });
-    collector.addExpr({ expression: 'a', result: 1, timestamp: Date.now() });
-    collector.addEvent({ action: 'click', timestamp: Date.now() });
-    expect(collector.getEntries()).toHaveLength(3);
-  });
-
-  it('should notify subscribers on new entry', () => {
-    const collector = DebugCollector.getInstance();
-    const fn = vi.fn();
-    collector.subscribe(fn);
-    collector.addPerf({ type: 'card', durationMs: 2, timestamp: Date.now() });
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith(expect.objectContaining({ kind: 'perf' }));
-  });
-
-  it('should allow unsubscribe', () => {
-    const collector = DebugCollector.getInstance();
-    const fn = vi.fn();
-    const unsub = collector.subscribe(fn);
-    unsub();
-    collector.addPerf({ type: 'x', durationMs: 0, timestamp: Date.now() });
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('should clear entries', () => {
-    const collector = DebugCollector.getInstance();
-    collector.addPerf({ type: 'x', durationMs: 0, timestamp: Date.now() });
-    collector.addExpr({ expression: 'a', result: 1, timestamp: Date.now() });
-    collector.clear();
-    expect(collector.getEntries()).toHaveLength(0);
-  });
-
-  it('should cap entries at MAX_ENTRIES', () => {
-    const collector = DebugCollector.getInstance();
-    for (let i = 0; i < 250; i++) {
-      collector.addPerf({ type: `c${i}`, durationMs: i, timestamp: Date.now() });
-    }
-    // MAX_ENTRIES is 200
-    expect(collector.getEntries().length).toBeLessThanOrEqual(200);
-  });
-
-  it('should swallow subscriber errors gracefully', () => {
-    const collector = DebugCollector.getInstance();
-    const badFn = vi.fn(() => { throw new Error('boom'); });
-    const goodFn = vi.fn();
-    collector.subscribe(badFn);
-    collector.subscribe(goodFn);
-    collector.addPerf({ type: 'x', durationMs: 0, timestamp: Date.now() });
-    expect(goodFn).toHaveBeenCalledTimes(1);
-  });
-});

package/src/utils/__tests__/debug.test.ts

@@ -1,134 +0,0 @@
-/**
- * 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 { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { debugLog, debugTime, debugTimeEnd, parseDebugFlags, isDebugEnabled } from '../debug';
-
-describe('Debug Utilities', () => {
-  let consoleSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    (globalThis as any).OBJECTUI_DEBUG = undefined;
-  });
-
-  describe('debugLog', () => {
-    it('should not log when debug is disabled', () => {
-      (globalThis as any).OBJECTUI_DEBUG = false;
-      debugLog('schema', 'test message');
-      expect(consoleSpy).not.toHaveBeenCalled();
-    });
-
-    it('should log when OBJECTUI_DEBUG is true', () => {
-      (globalThis as any).OBJECTUI_DEBUG = true;
-      debugLog('schema', 'Resolving component');
-      expect(consoleSpy).toHaveBeenCalledWith('[ObjectUI Debug][schema] Resolving component');
-    });
-
-    it('should log with data when provided', () => {
-      (globalThis as any).OBJECTUI_DEBUG = true;
-      debugLog('registry', 'Registered', { type: 'Button' });
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[ObjectUI Debug][registry] Registered',
-        { type: 'Button' }
-      );
-    });
-
-    it('should not log when debug is undefined', () => {
-      debugLog('action', 'test');
-      expect(consoleSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('debugTime / debugTimeEnd', () => {
-    it('should not log timing when debug is disabled', () => {
-      (globalThis as any).OBJECTUI_DEBUG = false;
-      debugTime('test-timer');
-      debugTimeEnd('test-timer');
-      expect(consoleSpy).not.toHaveBeenCalled();
-    });
-
-    it('should measure and log elapsed time when debug is enabled', () => {
-      (globalThis as any).OBJECTUI_DEBUG = true;
-      debugTime('render-test');
-
-      // Simulate some delay via a busy loop
-      const start = performance.now();
-      while (performance.now() - start < 5) {
-        // wait ~5ms
-      }
-
-      debugTimeEnd('render-test');
-      expect(consoleSpy).toHaveBeenCalledTimes(1);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringMatching(/^\[ObjectUI Debug\]\[perf\] render-test: \d+\.\d{2}ms$/)
-      );
-    });
-
-    it('should not log if debugTimeEnd is called without debugTime', () => {
-      (globalThis as any).OBJECTUI_DEBUG = true;
-      debugTimeEnd('nonexistent');
-      expect(consoleSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('parseDebugFlags', () => {
-    it('should return enabled:false for empty search string', () => {
-      expect(parseDebugFlags('')).toEqual({ enabled: false });
-    });
-
-    it('should detect __debug master switch', () => {
-      expect(parseDebugFlags('?__debug')).toEqual({ enabled: true });
-    });
-
-    it('should detect individual sub-flags', () => {
-      expect(parseDebugFlags('?__debug_schema')).toEqual({ enabled: true, schema: true });
-      expect(parseDebugFlags('?__debug_perf')).toEqual({ enabled: true, perf: true });
-      expect(parseDebugFlags('?__debug_data')).toEqual({ enabled: true, data: true });
-      expect(parseDebugFlags('?__debug_expr')).toEqual({ enabled: true, expr: true });
-      expect(parseDebugFlags('?__debug_events')).toEqual({ enabled: true, events: true });
-      expect(parseDebugFlags('?__debug_registry')).toEqual({ enabled: true, registry: true });
-    });
-
-    it('should combine multiple sub-flags', () => {
-      const flags = parseDebugFlags('?__debug_schema&__debug_perf&__debug_data');
-      expect(flags).toEqual({ enabled: true, schema: true, perf: true, data: true });
-    });
-
-    it('should handle unrelated params gracefully', () => {
-      const flags = parseDebugFlags('?foo=bar&baz=1');
-      expect(flags).toEqual({ enabled: false });
-    });
-
-    it('should handle __debug mixed with sub-flags', () => {
-      const flags = parseDebugFlags('?__debug&__debug_schema');
-      expect(flags).toEqual({ enabled: true, schema: true });
-    });
-  });
-
-  describe('isDebugEnabled', () => {
-    it('should return true when globalThis.OBJECTUI_DEBUG is true', () => {
-      (globalThis as any).OBJECTUI_DEBUG = true;
-      expect(isDebugEnabled()).toBe(true);
-    });
-
-    it('should return true when globalThis.OBJECTUI_DEBUG is "true"', () => {
-      (globalThis as any).OBJECTUI_DEBUG = 'true';
-      expect(isDebugEnabled()).toBe(true);
-    });
-
-    it('should return false when no debug flag is set', () => {
-      (globalThis as any).OBJECTUI_DEBUG = undefined;
-      expect(isDebugEnabled()).toBe(false);
-    });
-  });
-});

package/src/utils/__tests__/expand-fields.test.ts

@@ -1,120 +0,0 @@
-/**
- * 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 { describe, it, expect } from 'vitest';
-import { buildExpandFields } from '../expand-fields';
-
-describe('buildExpandFields', () => {
-  const sampleFields = {
-    name: { type: 'text', label: 'Name' },
-    email: { type: 'email', label: 'Email' },
-    account: { type: 'lookup', label: 'Account', reference_to: 'accounts' },
-    parent: { type: 'master_detail', label: 'Parent', reference_to: 'contacts' },
-    status: { type: 'select', label: 'Status' },
-  };
-
-  it('should return lookup and master_detail field names', () => {
-    const result = buildExpandFields(sampleFields);
-    expect(result).toEqual(['account', 'parent']);
-  });
-
-  it('should return empty array when no lookup/master_detail fields exist', () => {
-    const fields = {
-      name: { type: 'text' },
-      age: { type: 'number' },
-    };
-    expect(buildExpandFields(fields)).toEqual([]);
-  });
-
-  it('should return empty array for null/undefined schema', () => {
-    expect(buildExpandFields(null)).toEqual([]);
-    expect(buildExpandFields(undefined)).toEqual([]);
-  });
-
-  it('should return empty array for empty fields object', () => {
-    expect(buildExpandFields({})).toEqual([]);
-  });
-
-  it('should filter by string columns when provided', () => {
-    const result = buildExpandFields(sampleFields, ['name', 'account']);
-    expect(result).toEqual(['account']);
-  });
-
-  it('should filter by ListColumn objects with field property', () => {
-    const columns = [
-      { field: 'name', label: 'Name' },
-      { field: 'parent', label: 'Parent Contact' },
-    ];
-    const result = buildExpandFields(sampleFields, columns);
-    expect(result).toEqual(['parent']);
-  });
-
-  it('should support columns with name property', () => {
-    const columns = [
-      { name: 'account', label: 'Account' },
-    ];
-    const result = buildExpandFields(sampleFields, columns);
-    expect(result).toEqual(['account']);
-  });
-
-  it('should support columns with fieldName property', () => {
-    const columns = [
-      { fieldName: 'parent', label: 'Parent' },
-    ];
-    const result = buildExpandFields(sampleFields, columns);
-    expect(result).toEqual(['parent']);
-  });
-
-  it('should return empty array when columns have no lookup fields', () => {
-    const result = buildExpandFields(sampleFields, ['name', 'email']);
-    expect(result).toEqual([]);
-  });
-
-  it('should handle mixed string and object columns', () => {
-    const columns = [
-      'name',
-      { field: 'account' },
-      'parent',
-    ];
-    const result = buildExpandFields(sampleFields, columns);
-    expect(result).toEqual(['account', 'parent']);
-  });
-
-  it('should return all lookup fields when columns is empty array', () => {
-    // Empty columns array does not satisfy the length > 0 check,
-    // so no column restriction is applied → all lookup fields returned
-    const result = buildExpandFields(sampleFields, []);
-    expect(result).toEqual(['account', 'parent']);
-  });
-
-  it('should handle malformed field definitions gracefully', () => {
-    const fields = {
-      name: null,
-      account: { type: 'lookup' },
-      broken: 'not-an-object',
-      empty: {},
-    };
-    const result = buildExpandFields(fields as any);
-    expect(result).toEqual(['account']);
-  });
-
-  it('should handle only lookup fields', () => {
-    const fields = {
-      ref1: { type: 'lookup', reference_to: 'obj1' },
-      ref2: { type: 'lookup', reference_to: 'obj2' },
-    };
-    expect(buildExpandFields(fields)).toEqual(['ref1', 'ref2']);
-  });
-
-  it('should handle only master_detail fields', () => {
-    const fields = {
-      detail1: { type: 'master_detail', reference_to: 'obj1' },
-    };
-    expect(buildExpandFields(fields)).toEqual(['detail1']);
-  });
-});

package/src/utils/__tests__/extract-records.test.ts

@@ -1,50 +0,0 @@
-/**
- * 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 { describe, it, expect } from 'vitest';
-import { extractRecords } from '../extract-records';
-
-describe('extractRecords', () => {
-  const sampleData = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
-
-  it('should return the array directly when results is an array', () => {
-    expect(extractRecords(sampleData)).toEqual(sampleData);
-  });
-
-  it('should extract from results.records', () => {
-    expect(extractRecords({ records: sampleData })).toEqual(sampleData);
-  });
-
-  it('should extract from results.data', () => {
-    expect(extractRecords({ data: sampleData })).toEqual(sampleData);
-  });
-
-  it('should extract from results.value', () => {
-    expect(extractRecords({ value: sampleData })).toEqual(sampleData);
-  });
-
-  it('should return empty array for null/undefined', () => {
-    expect(extractRecords(null)).toEqual([]);
-    expect(extractRecords(undefined)).toEqual([]);
-  });
-
-  it('should return empty array for non-array/non-object', () => {
-    expect(extractRecords('string')).toEqual([]);
-    expect(extractRecords(42)).toEqual([]);
-  });
-
-  it('should return empty array for object without recognized keys', () => {
-    expect(extractRecords({ total: 100 })).toEqual([]);
-  });
-
-  it('should prefer records over data and value', () => {
-    const records = [{ id: 1 }];
-    const data = [{ id: 2 }];
-    expect(extractRecords({ records, data })).toEqual(records);
-  });
-});

package/src/utils/__tests__/filter-converter.test.ts

@@ -1,118 +0,0 @@
-/**
- * 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 { describe, it, expect, vi } from 'vitest';
-import { convertFiltersToAST, convertOperatorToAST, type FilterNode } from '../filter-converter';
-
-describe('Filter Converter Utilities', () => {
-  describe('convertOperatorToAST', () => {
-    it('should convert known operators', () => {
-      expect(convertOperatorToAST('$eq')).toBe('=');
-      expect(convertOperatorToAST('$ne')).toBe('!=');
-      expect(convertOperatorToAST('$gt')).toBe('>');
-      expect(convertOperatorToAST('$gte')).toBe('>=');
-      expect(convertOperatorToAST('$lt')).toBe('<');
-      expect(convertOperatorToAST('$lte')).toBe('<=');
-      expect(convertOperatorToAST('$in')).toBe('in');
-      expect(convertOperatorToAST('$nin')).toBe('notin');
-      expect(convertOperatorToAST('$notin')).toBe('notin');
-      expect(convertOperatorToAST('$contains')).toBe('contains');
-      expect(convertOperatorToAST('$startswith')).toBe('startswith');
-      expect(convertOperatorToAST('$between')).toBe('between');
-    });
-
-    it('should return null for unknown operators', () => {
-      expect(convertOperatorToAST('$unknown')).toBe(null);
-      expect(convertOperatorToAST('$exists')).toBe(null);
-    });
-  });
-
-  describe('convertFiltersToAST', () => {
-    it('should convert simple equality filter', () => {
-      const result = convertFiltersToAST({ status: 'active' });
-      expect(result).toEqual(['status', '=', 'active']);
-    });
-
-    it('should convert single operator filter', () => {
-      const result = convertFiltersToAST({ age: { $gte: 18 } });
-      expect(result).toEqual(['age', '>=', 18]);
-    });
-
-    it('should convert multiple operators on same field', () => {
-      const result = convertFiltersToAST({ age: { $gte: 18, $lte: 65 } }) as FilterNode;
-      expect(result[0]).toBe('and');
-      expect(result.slice(1)).toContainEqual(['age', '>=', 18]);
-      expect(result.slice(1)).toContainEqual(['age', '<=', 65]);
-    });
-
-    it('should convert multiple fields with and logic', () => {
-      const result = convertFiltersToAST({
-        age: { $gte: 18 },
-        status: 'active'
-      }) as FilterNode;
-      expect(result[0]).toBe('and');
-      expect(result.slice(1)).toContainEqual(['age', '>=', 18]);
-      expect(result.slice(1)).toContainEqual(['status', '=', 'active']);
-    });
-
-    it('should handle $in operator', () => {
-      const result = convertFiltersToAST({
-        status: { $in: ['active', 'pending'] }
-      });
-      expect(result).toEqual(['status', 'in', ['active', 'pending']]);
-    });
-
-    it('should handle $nin operator', () => {
-      const result = convertFiltersToAST({
-        status: { $nin: ['archived'] }
-      });
-      expect(result).toEqual(['status', 'notin', ['archived']]);
-    });
-
-    it('should warn on $regex operator and convert to contains', () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      
-      const result = convertFiltersToAST({
-        name: { $regex: '^John' }
-      });
-      
-      expect(result).toEqual(['name', 'contains', '^John']);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[ObjectUI] Warning: $regex operator is not fully supported')
-      );
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should throw error on unknown operator', () => {
-      expect(() => {
-        convertFiltersToAST({ age: { $unknown: 18 } });
-      }).toThrow('[ObjectUI] Unknown filter operator');
-    });
-
-    it('should skip null and undefined values', () => {
-      const result = convertFiltersToAST({
-        name: 'John',
-        age: null,
-        email: undefined
-      });
-      expect(result).toEqual(['name', '=', 'John']);
-    });
-
-    it('should return original filter if empty after filtering', () => {
-      const result = convertFiltersToAST({
-        age: null,
-        email: undefined
-      });
-      expect(result).toEqual({
-        age: null,
-        email: undefined
-      });
-    });
-  });
-});

package/src/utils/__tests__/merge-views-into-objects.test.ts

@@ -1,110 +0,0 @@
-/**
- * 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 { describe, it, expect } from 'vitest';
-import { mergeViewsIntoObjects } from '../merge-views-into-objects';
-
-describe('mergeViewsIntoObjects', () => {
-  it('should merge listViews from views into corresponding objects', () => {
-    const objects = [{ name: 'account', label: 'Account', fields: {} }];
-    const views = [
-      {
-        listViews: {
-          all_accounts: {
-            name: 'all_accounts',
-            label: 'All Accounts',
-            type: 'grid',
-            data: { provider: 'object', object: 'account' },
-          },
-        },
-      },
-    ];
-
-    const result = mergeViewsIntoObjects(objects, views);
-    expect(result[0].listViews.all_accounts).toBeDefined();
-    expect(result[0].listViews.all_accounts.label).toBe('All Accounts');
-  });
-
-  it('should preserve existing listViews on objects', () => {
-    const objects = [
-      {
-        name: 'todo_task',
-        label: 'Task',
-        fields: {},
-        listViews: {
-          existing: { name: 'existing', label: 'Existing View', type: 'grid', data: { provider: 'object', object: 'todo_task' } },
-        },
-      },
-    ];
-    const views = [
-      {
-        listViews: {
-          new_view: {
-            name: 'new_view',
-            label: 'New View',
-            type: 'grid',
-            data: { provider: 'object', object: 'todo_task' },
-          },
-        },
-      },
-    ];
-
-    const result = mergeViewsIntoObjects(objects, views);
-    const task = result[0];
-    expect(task.listViews.existing).toBeDefined();
-    expect(task.listViews.new_view).toBeDefined();
-  });
-
-  it('should ignore listViews without data.object', () => {
-    const objects = [{ name: 'account', label: 'Account', fields: {} }];
-    const views = [
-      {
-        listViews: {
-          orphan: { name: 'orphan', label: 'Orphan View', type: 'grid' },
-        },
-      },
-    ];
-
-    const result = mergeViewsIntoObjects(objects, views);
-    expect(result[0].listViews).toBeUndefined();
-  });
-
-  it('should return objects unchanged when views is empty', () => {
-    const objects = [{ name: 'account', label: 'Account', fields: {} }];
-
-    const result = mergeViewsIntoObjects(objects, []);
-    expect(result).toEqual(objects);
-  });
-
-  it('should ignore views without listViews property', () => {
-    const objects = [{ name: 'account', label: 'Account', fields: {} }];
-    const views = [{ someOtherProp: true }];
-
-    const result = mergeViewsIntoObjects(objects, views);
-    expect(result).toEqual(objects);
-  });
-
-  it('should merge views from multiple view entries into different objects', () => {
-    const objects = [
-      { name: 'account', label: 'Account', fields: {} },
-      { name: 'contact', label: 'Contact', fields: {} },
-    ];
-    const views = [
-      {
-        listViews: {
-          all_accounts: { name: 'all_accounts', label: 'All Accounts', type: 'grid', data: { provider: 'object', object: 'account' } },
-          all_contacts: { name: 'all_contacts', label: 'All Contacts', type: 'grid', data: { provider: 'object', object: 'contact' } },
-        },
-      },
-    ];
-
-    const result = mergeViewsIntoObjects(objects, views);
-    expect(result[0].listViews.all_accounts).toBeDefined();
-    expect(result[1].listViews.all_contacts).toBeDefined();
-  });
-});