@object-ui/core 0.5.0 → 2.0.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @object-ui/core@0.5.0 build /home/runner/work/objectui/objectui/packages/core
+> @object-ui/core@2.0.0 build /home/runner/work/objectui/objectui/packages/core
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @object-ui/core
 
+## 2.0.0
+
+### Major Changes
+
+- b859617: Release v1.0.0 — unify all package versions to 1.0.0
+
+### Patch Changes
+
+- Updated dependencies [b859617]
+  - @object-ui/types@2.0.0
+
 ## 0.3.1
 
 ### Patch Changes

package/dist/actions/ActionRunner.d.ts

@@ -5,6 +5,15 @@
  * 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 Runner
+ *
+ * Executes actions defined in ActionSchema and EventHandler.
+ * Supports all spec v2.0.1 action types: script, url, modal, flow, api.
+ * Features: conditional execution, confirmation, toast notifications,
+ * redirect handling, action chaining, custom handler registration.
+ */
+import { ExpressionEvaluator } from '../evaluator/ExpressionEvaluator';
 export interface ActionResult {
     success: boolean;
     data?: any;
@@ -12,29 +21,244 @@ export interface ActionResult {
     reload?: boolean;
     close?: boolean;
     redirect?: string;
+    /** Modal schema to render (for type: 'modal') */
+    modal?: any;
 }
 export interface ActionContext {
     data?: Record<string, any>;
     record?: any;
+    selectedRecords?: Record<string, any>[];
     user?: any;
     [key: string]: any;
 }
-export type ActionHandler = (action: any, context: ActionContext) => Promise<ActionResult> | ActionResult;
+/**
+ * API configuration for complex requests.
+ */
+export interface ApiConfig {
+    /** API endpoint URL */
+    url: string;
+    /** HTTP method */
+    method?: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body (will be JSON-stringified if object) */
+    body?: any;
+    /** Query parameters */
+    queryParams?: Record<string, string>;
+    /** Response type */
+    responseType?: 'json' | 'text' | 'blob';
+}
+/**
+ * Action definition accepted by the runner.
+ * Compatible with both UIActionSchema (spec v2.0.1) and legacy crud.ts ActionSchema.
+ */
+export interface ActionDef {
+    /** Action type identifier: 'script' | 'url' | 'modal' | 'flow' | 'api' | 'navigation' | custom */
+    type?: string;
+    /** Legacy action type field */
+    actionType?: string;
+    /** Action name (from UIActionSchema) */
+    name?: string;
+    /** Display label */
+    label?: string;
+    /** Confirmation text — shows a confirm dialog before executing */
+    confirmText?: string;
+    /** Structured confirmation (from crud.ts) */
+    confirm?: {
+        title?: string;
+        message?: string;
+        confirmText?: string;
+        cancelText?: string;
+    };
+    /** Condition expression — if falsy, skip action */
+    condition?: string;
+    /** Disabled expression — if truthy, skip action */
+    disabled?: string | boolean;
+    /** API endpoint (string URL or complex config) */
+    api?: string | ApiConfig;
+    /** API endpoint URL (spec v2.0.1 alias) */
+    endpoint?: string;
+    /** HTTP method */
+    method?: string;
+    /** Navigation target */
+    navigate?: any;
+    /** onClick callback (legacy) */
+    onClick?: () => void | Promise<void>;
+    /** Whether to reload data after success */
+    reload?: boolean;
+    /** Whether to close dialog after success */
+    close?: boolean;
+    /** Redirect URL expression */
+    redirect?: string;
+    /** Toast configuration */
+    toast?: {
+        showOnSuccess?: boolean;
+        showOnError?: boolean;
+        duration?: number;
+    };
+    /** Success message (from UIActionSchema) */
+    successMessage?: string;
+    /** Error message (from UIActionSchema) */
+    errorMessage?: string;
+    /** Whether to refresh data after execution (from UIActionSchema) */
+    refreshAfter?: boolean;
+    /** Params object (for custom handlers) */
+    params?: Record<string, any>;
+    /** ActionParam definitions to collect from user before execution (from spec ActionSchema.params) */
+    actionParams?: ActionParamDef[];
+    /** Script/expression to execute (for type: 'script') */
+    execute?: string;
+    /** Target URL or identifier (for type: 'url', 'modal', 'flow') */
+    target?: string;
+    /** Modal schema to open (for type: 'modal') */
+    modal?: any;
+    /** Chained actions to execute after this one */
+    chain?: ActionDef[];
+    /** Chain execution mode */
+    chainMode?: 'sequential' | 'parallel';
+    /** Callback on success */
+    onSuccess?: ActionDef | ActionDef[];
+    /** Callback on failure */
+    onFailure?: ActionDef | ActionDef[];
+    /** Any additional properties */
+    [key: string]: any;
+}
+export type ActionHandler = (action: ActionDef, context: ActionContext) => Promise<ActionResult> | ActionResult;
+/**
+ * Confirmation handler — replaces window.confirm.
+ * Consumers can provide an async implementation (e.g., Shadcn AlertDialog).
+ */
+export type ConfirmationHandler = (message: string, options?: {
+    title?: string;
+    confirmText?: string;
+    cancelText?: string;
+}) => Promise<boolean>;
+/**
+ * Toast handler — consumers can wire to Sonner or any toast library.
+ */
+export type ToastHandler = (message: string, options?: {
+    type?: 'success' | 'error' | 'info' | 'warning';
+    duration?: number;
+}) => void;
+/**
+ * Modal handler — consumers provide to render modal dialogs.
+ */
+export type ModalHandler = (schema: any, context: ActionContext) => Promise<ActionResult>;
+/**
+ * Navigation handler — consumers provide for SPA-aware routing.
+ */
+export type NavigationHandler = (url: string, options?: {
+    external?: boolean;
+    newTab?: boolean;
+    replace?: boolean;
+}) => void;
+/**
+ * Param collection handler — consumers provide to show a dialog
+ * for collecting ActionParam values before action execution.
+ * Returns collected values, or null if cancelled.
+ */
+export type ParamCollectionHandler = (params: ActionParamDef[]) => Promise<Record<string, any> | null>;
+/**
+ * ActionParam definition accepted by the runner.
+ * Compatible with @objectstack/spec ActionParam.
+ */
+export interface ActionParamDef {
+    name: string;
+    label: string;
+    type: string;
+    required?: boolean;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    defaultValue?: unknown;
+    helpText?: string;
+    placeholder?: string;
+    validation?: string;
+}
 export declare class ActionRunner {
     private handlers;
     private evaluator;
     private context;
+    private confirmHandler;
+    private toastHandler;
+    private modalHandler;
+    private navigationHandler;
+    private paramCollectionHandler;
     constructor(context?: ActionContext);
+    /**
+     * Set a custom confirmation handler (e.g., Shadcn AlertDialog).
+     */
+    setConfirmHandler(handler: ConfirmationHandler): void;
+    /**
+     * Set a custom toast handler (e.g., Sonner).
+     */
+    setToastHandler(handler: ToastHandler): void;
+    /**
+     * Set a modal handler (e.g., render a Dialog via React state).
+     */
+    setModalHandler(handler: ModalHandler): void;
+    /**
+     * Set a navigation handler (e.g., React Router navigate).
+     */
+    setNavigationHandler(handler: NavigationHandler): void;
+    /**
+     * Set a param collection handler — shows a dialog to collect
+     * ActionParam values before action execution.
+     */
+    setParamCollectionHandler(handler: ParamCollectionHandler): void;
     registerHandler(actionName: string, handler: ActionHandler): void;
-    execute(action: any): Promise<ActionResult>;
+    unregisterHandler(actionName: string): void;
+    execute(action: ActionDef): Promise<ActionResult>;
+    /**
+     * Execute multiple actions in sequence or parallel.
+     */
+    executeChain(actions: ActionDef[], mode?: 'sequential' | 'parallel'): Promise<ActionResult>;
+    /**
+     * Post-execution: emit toast notifications, handle chaining, callbacks.
+     */
+    private handlePostExecution;
+    /**
+     * Execute script action — evaluates client-side expression via ExpressionEvaluator.
+     * Supports ${} template expressions referencing data, record, user context.
+     */
+    private executeScript;
+    /**
+     * Execute URL action — navigate to a URL.
+     * Uses navigationHandler for SPA routing, falls back to window.location.
+     */
+    private executeUrl;
+    /**
+     * Execute modal action — open a dialog.
+     * Delegates to the registered modalHandler; returns modal schema if no handler.
+     */
+    private executeModal;
+    /**
+     * Execute flow action — trigger a workflow/automation.
+     * Delegates to a registered 'flow' handler; otherwise returns not-implemented.
+     */
+    private executeFlow;
     private executeActionSchema;
     /**
      * Execute navigation action
      */
     private executeNavigation;
+    /**
+     * Execute API action — supports both simple string endpoint and complex ApiConfig.
+     */
     private executeAPI;
-    private showConfirmation;
+    /**
+     * Validate URL to prevent javascript: or data: protocol injection.
+     */
+    private isValidUrl;
     updateContext(newContext: Partial<ActionContext>): void;
     getContext(): ActionContext;
+    /**
+     * Get the expression evaluator (for components that need to evaluate visibility, etc.)
+     */
+    getEvaluator(): ExpressionEvaluator;
 }
-export declare function executeAction(action: any, context?: ActionContext): Promise<ActionResult>;
+/**
+ * Convenience function to execute a single action with a one-off runner.
+ */
+export declare function executeAction(action: ActionDef, context?: ActionContext): Promise<ActionResult>;