@object-ui/core 3.3.0 → 3.3.2

package/src/__tests__/protocols/SharingProtocol.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { SharingConfig, EmbedConfig } from '@object-ui/types';
-import {
-  resolveSharingConfig,
-  resolveEmbedConfig,
-  generateEmbedCode,
-  validateSharingConfig,
-} from '../../protocols/SharingProtocol';
-
-describe('SharingProtocol', () => {
-  // ==========================================================================
-  // resolveSharingConfig
-  // ==========================================================================
-  describe('resolveSharingConfig', () => {
-    it('should apply defaults for empty config', () => {
-      const resolved = resolveSharingConfig({});
-
-      expect(resolved.enabled).toBe(false);
-      expect(resolved.allowedDomains).toEqual([]);
-      expect(resolved.allowAnonymous).toBe(false);
-      expect(resolved.publicLink).toBeUndefined();
-      expect(resolved.password).toBeUndefined();
-      expect(resolved.expiresAt).toBeUndefined();
-    });
-
-    it('should preserve explicit values', () => {
-      const config: Partial<SharingConfig> = {
-        enabled: true,
-        publicLink: 'https://example.com/share/abc',
-        password: 'secret',
-        allowedDomains: ['example.com'],
-        expiresAt: '2025-12-31T00:00:00Z',
-        allowAnonymous: true,
-      };
-      const resolved = resolveSharingConfig(config);
-
-      expect(resolved.enabled).toBe(true);
-      expect(resolved.publicLink).toBe('https://example.com/share/abc');
-      expect(resolved.password).toBe('secret');
-      expect(resolved.allowedDomains).toEqual(['example.com']);
-      expect(resolved.expiresAt).toBe('2025-12-31T00:00:00Z');
-      expect(resolved.allowAnonymous).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // resolveEmbedConfig
-  // ==========================================================================
-  describe('resolveEmbedConfig', () => {
-    it('should apply defaults for empty config', () => {
-      const resolved = resolveEmbedConfig({});
-
-      expect(resolved.enabled).toBe(false);
-      expect(resolved.allowedOrigins).toEqual([]);
-      expect(resolved.width).toBe('100%');
-      expect(resolved.height).toBe('600px');
-      expect(resolved.showHeader).toBe(true);
-      expect(resolved.showNavigation).toBe(false);
-      expect(resolved.responsive).toBe(true);
-    });
-
-    it('should preserve explicit values', () => {
-      const config: Partial<EmbedConfig> = {
-        enabled: true,
-        width: '800px',
-        height: '400px',
-        showHeader: false,
-        responsive: false,
-      };
-      const resolved = resolveEmbedConfig(config);
-
-      expect(resolved.enabled).toBe(true);
-      expect(resolved.width).toBe('800px');
-      expect(resolved.height).toBe('400px');
-      expect(resolved.showHeader).toBe(false);
-      expect(resolved.responsive).toBe(false);
-    });
-  });
-
-  // ==========================================================================
-  // generateEmbedCode
-  // ==========================================================================
-  describe('generateEmbedCode', () => {
-    it('should return valid iframe HTML', () => {
-      const config = {} as EmbedConfig;
-      const html = generateEmbedCode(config, 'https://app.example.com/view/123');
-
-      expect(html).toContain('<iframe');
-      expect(html).toContain('</iframe>');
-      expect(html).toContain('src="https://app.example.com/view/123"');
-      expect(html).toContain('width="100%"');
-      expect(html).toContain('height="600px"');
-      expect(html).toContain('allowfullscreen');
-    });
-
-    it('should include responsive style when responsive is true', () => {
-      const config = { responsive: true } as EmbedConfig;
-      const html = generateEmbedCode(config, 'https://example.com');
-
-      expect(html).toContain('max-width: 100%');
-    });
-
-    it('should not include max-width when responsive is false', () => {
-      const config = { responsive: false } as EmbedConfig;
-      const html = generateEmbedCode(config, 'https://example.com');
-
-      expect(html).not.toContain('max-width');
-    });
-
-    it('should HTML-escape URLs to prevent XSS', () => {
-      const config = {} as EmbedConfig;
-      const maliciousUrl = 'https://example.com/"><script>alert("xss")</script>';
-      const html = generateEmbedCode(config, maliciousUrl);
-
-      expect(html).not.toContain('<script>');
-      expect(html).toContain('&lt;script&gt;');
-      expect(html).toContain('&quot;');
-    });
-  });
-
-  // ==========================================================================
-  // validateSharingConfig
-  // ==========================================================================
-  describe('validateSharingConfig', () => {
-    it('should return valid for a well-formed config', () => {
-      const config = {
-        enabled: true,
-        publicLink: 'https://example.com/share/abc',
-        allowedDomains: ['example.com'],
-      } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it('should error when enabled without publicLink', () => {
-      const config = { enabled: true } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('A public link is required when sharing is enabled.');
-    });
-
-    it('should error for invalid expiresAt date', () => {
-      const config = {
-        enabled: false,
-        expiresAt: 'not-a-date',
-      } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('expiresAt must be a valid ISO 8601 date string.');
-    });
-
-    it('should error for empty password string', () => {
-      const config = {
-        enabled: false,
-        password: '',
-      } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Password must not be an empty string when provided.');
-    });
-
-    it('should error for empty domain entries', () => {
-      const config = {
-        enabled: false,
-        allowedDomains: ['example.com', '  '],
-      } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain(
-        'allowedDomains contains an empty or whitespace-only entry.'
-      );
-    });
-
-    it('should return valid for disabled config with no issues', () => {
-      const config = { enabled: false } as SharingConfig;
-      const result = validateSharingConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-  });
-});

package/src/actions/ActionEngine.ts

@@ -1,268 +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.
- */
-
-/**
- * @object-ui/core - Action Engine
- * 
- * Declarative action dispatch engine. Manages action registration,
- * event-to-action mapping, location-based filtering, keyboard shortcuts,
- * and bulk operation support.
- * 
- * Replaces callback-based patterns with a schema-driven pipeline:
- *   ActionSchema[] → ActionEngine → ActionRunner → ActionResult
- */
-
-import { ActionRunner, type ActionDef, type ActionContext, type ActionResult } from './ActionRunner';
-
-/** Action location types (from @objectstack/spec) */
-export type ActionLocation =
-  | 'list_toolbar'
-  | 'list_item'
-  | 'record_header'
-  | 'record_more'
-  | 'record_related'
-  | 'global_nav';
-
-/** Registered action with metadata */
-export interface RegisteredAction {
-  action: ActionDef;
-  locations: ActionLocation[];
-  /** Keyboard shortcut (e.g., 'ctrl+s', 'meta+k') */
-  shortcut?: string;
-  /** Whether this action supports bulk operations */
-  bulkEnabled?: boolean;
-  /** Priority for ordering (lower = first) */
-  priority?: number;
-}
-
-/** Event-to-action mapping */
-export interface ActionMapping {
-  /** Event name (e.g., 'row:click', 'toolbar:save', 'keyboard:ctrl+s') */
-  event: string;
-  /** Action name to execute */
-  actionName: string;
-  /** Optional condition expression */
-  condition?: string;
-}
-
-/** Keyboard shortcut handler */
-export interface ShortcutBinding {
-  /** Key combination (e.g., 'ctrl+s', 'meta+k', 'shift+n') */
-  keys: string;
-  /** Action name to trigger */
-  actionName: string;
-}
-
-/** Normalize a shortcut string for comparison (lowercase, trimmed, sorted parts) */
-function normalizeShortcut(keys: string): string {
-  return keys.toLowerCase().split('+').map(k => k.trim()).sort().join('+');
-}
-
-export class ActionEngine {
-  private actions = new Map<string, RegisteredAction>();
-  private mappings: ActionMapping[] = [];
-  private shortcuts: ShortcutBinding[] = [];
-  private normalizedShortcutMap = new Map<string, string>();
-  private runner: ActionRunner;
-
-  constructor(context: ActionContext = {}) {
-    this.runner = new ActionRunner(context);
-  }
-
-  /** Get the underlying ActionRunner for handler configuration */
-  getRunner(): ActionRunner {
-    return this.runner;
-  }
-
-  /** Register a single action */
-  registerAction(action: ActionDef, options?: {
-    locations?: ActionLocation[];
-    shortcut?: string;
-    bulkEnabled?: boolean;
-    priority?: number;
-  }): void {
-    const name = action.name || action.type || '';
-    if (!name) throw new Error('Action must have a name or type');
-    
-    this.actions.set(name, {
-      action,
-      locations: options?.locations || [],
-      shortcut: options?.shortcut,
-      bulkEnabled: options?.bulkEnabled ?? false,
-      priority: options?.priority ?? 100,
-    });
-
-    // Auto-register keyboard shortcut
-    if (options?.shortcut) {
-      this.shortcuts.push({ keys: options.shortcut, actionName: name });
-      this.normalizedShortcutMap.set(normalizeShortcut(options.shortcut), name);
-    }
-  }
-
-  /** Register multiple actions from an ActionSchema array */
-  registerActions(actions: ActionDef[]): void {
-    for (const action of actions) {
-      this.registerAction(action, {
-        locations: (action as any).locations,
-        shortcut: (action as any).shortcut,
-        bulkEnabled: (action as any).bulkEnabled,
-      });
-    }
-  }
-
-  /** Unregister an action by name */
-  unregisterAction(name: string): void {
-    const registered = this.actions.get(name);
-    if (registered?.shortcut) {
-      this.normalizedShortcutMap.delete(normalizeShortcut(registered.shortcut));
-    }
-    this.actions.delete(name);
-    this.shortcuts = this.shortcuts.filter(s => s.actionName !== name);
-    this.mappings = this.mappings.filter(m => m.actionName !== name);
-  }
-
-  /** Add an event-to-action mapping */
-  addMapping(mapping: ActionMapping): void {
-    this.mappings.push(mapping);
-  }
-
-  /** Get actions available at a specific location, sorted by priority */
-  getActionsForLocation(location: ActionLocation): ActionDef[] {
-    return Array.from(this.actions.values())
-      .filter(ra => ra.locations.includes(location))
-      .sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100))
-      .map(ra => ra.action);
-  }
-
-  /** Get actions that support bulk operations */
-  getBulkActions(): ActionDef[] {
-    return Array.from(this.actions.values())
-      .filter(ra => ra.bulkEnabled)
-      .sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100))
-      .map(ra => ra.action);
-  }
-
-  /** Get all registered keyboard shortcuts */
-  getShortcuts(): ShortcutBinding[] {
-    return [...this.shortcuts];
-  }
-
-  /** Get a registered action by name */
-  getAction(name: string): ActionDef | undefined {
-    return this.actions.get(name)?.action;
-  }
-
-  /** Execute an action by name */
-  async executeAction(name: string, contextOverride?: Partial<ActionContext>): Promise<ActionResult> {
-    const registered = this.actions.get(name);
-    if (!registered) {
-      return { success: false, error: `Action not found: ${name}` };
-    }
-
-    if (contextOverride) {
-      this.runner.updateContext(contextOverride);
-    }
-
-    return this.runner.execute(registered.action);
-  }
-
-  /** Dispatch an event — finds mapped actions and executes them */
-  async dispatch(event: string, contextOverride?: Partial<ActionContext>): Promise<ActionResult[]> {
-    const matchingMappings = this.mappings.filter(m => m.event === event);
-    
-    if (matchingMappings.length === 0) {
-      return [];
-    }
-
-    const results: ActionResult[] = [];
-    for (const mapping of matchingMappings) {
-      // Check condition if present
-      if (mapping.condition) {
-        const evaluator = this.runner.getEvaluator();
-        const shouldRun = evaluator.evaluateCondition(mapping.condition);
-        if (!shouldRun) continue;
-      }
-
-      const result = await this.executeAction(mapping.actionName, contextOverride);
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  /** Handle a keyboard shortcut event — returns true if handled */
-  async handleShortcut(keys: string, contextOverride?: Partial<ActionContext>): Promise<ActionResult | null> {
-    const actionName = this.normalizedShortcutMap.get(normalizeShortcut(keys));
-    if (!actionName) return null;
-    
-    return this.executeAction(actionName, contextOverride);
-  }
-
-  /** Execute a bulk operation on multiple records */
-  async executeBulk(
-    actionName: string,
-    records: Record<string, any>[],
-    options?: { parallel?: boolean; continueOnError?: boolean }
-  ): Promise<{ total: number; succeeded: number; failed: number; results: ActionResult[] }> {
-    const registered = this.actions.get(actionName);
-    if (!registered) {
-      return { total: 0, succeeded: 0, failed: 0, results: [{ success: false, error: `Action not found: ${actionName}` }] };
-    }
-    if (!registered.bulkEnabled) {
-      return { total: 0, succeeded: 0, failed: 0, results: [{ success: false, error: `Action ${actionName} does not support bulk operations` }] };
-    }
-
-    const results: ActionResult[] = [];
-    let succeeded = 0;
-    let failed = 0;
-
-    if (options?.parallel) {
-      const promises = records.map(record => {
-        this.runner.updateContext({ record, selectedRecords: records });
-        return this.runner.execute(registered.action);
-      });
-      const settled = await Promise.allSettled(promises);
-      for (const r of settled) {
-        if (r.status === 'fulfilled') {
-          results.push(r.value);
-          if (r.value.success) succeeded++;
-          else failed++;
-        } else {
-          results.push({ success: false, error: r.reason?.message || 'Unknown error' });
-          failed++;
-        }
-      }
-    } else {
-      for (const record of records) {
-        this.runner.updateContext({ record, selectedRecords: records });
-        const result = await this.runner.execute(registered.action);
-        results.push(result);
-        if (result.success) succeeded++;
-        else {
-          failed++;
-          if (!options?.continueOnError) break;
-        }
-      }
-    }
-
-    return { total: records.length, succeeded, failed, results };
-  }
-
-  /** Update the action context */
-  updateContext(context: Partial<ActionContext>): void {
-    this.runner.updateContext(context);
-  }
-
-  /** Clear all registered actions and mappings */
-  clear(): void {
-    this.actions.clear();
-    this.mappings = [];
-    this.shortcuts = [];
-    this.normalizedShortcutMap.clear();
-  }
-}