@nuraly/lumenui 0.1.0 → 0.2.2

package/dist/src/components/canvas/data-node/data-node.types.js

@@ -0,0 +1,158 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Data node operation types
+ */
+export var DataOperation;
+(function (DataOperation) {
+    DataOperation["QUERY"] = "QUERY";
+    DataOperation["INSERT"] = "INSERT";
+    DataOperation["UPDATE"] = "UPDATE";
+    DataOperation["DELETE"] = "DELETE";
+    DataOperation["LIST"] = "LIST";
+    DataOperation["READ"] = "READ";
+    DataOperation["SEARCH"] = "SEARCH";
+    DataOperation["COPY"] = "COPY";
+    DataOperation["MOVE"] = "MOVE";
+    DataOperation["UPLOAD"] = "UPLOAD";
+    DataOperation["DOWNLOAD"] = "DOWNLOAD";
+    DataOperation["GET_SIGNED_URL"] = "GET_SIGNED_URL";
+    DataOperation["MARK_READ"] = "MARK_READ";
+    DataOperation["MARK_UNREAD"] = "MARK_UNREAD";
+})(DataOperation || (DataOperation = {}));
+/**
+ * Filter operators for query conditions
+ */
+export var FilterOperator;
+(function (FilterOperator) {
+    FilterOperator["EQUALS"] = "=";
+    FilterOperator["NOT_EQUALS"] = "!=";
+    FilterOperator["GREATER_THAN"] = ">";
+    FilterOperator["GREATER_OR_EQUAL"] = ">=";
+    FilterOperator["LESS_THAN"] = "<";
+    FilterOperator["LESS_OR_EQUAL"] = "<=";
+    FilterOperator["IN"] = "in";
+    FilterOperator["NOT_IN"] = "notIn";
+    FilterOperator["LIKE"] = "like";
+    FilterOperator["IS_NULL"] = "isNull";
+    FilterOperator["IS_NOT_NULL"] = "isNotNull";
+})(FilterOperator || (FilterOperator = {}));
+/**
+ * Available filter operators with metadata
+ */
+export const FILTER_OPERATORS = [
+    { value: FilterOperator.EQUALS, label: 'equals', types: ['string', 'number', 'boolean'] },
+    { value: FilterOperator.NOT_EQUALS, label: 'not equals', types: ['string', 'number', 'boolean'] },
+    { value: FilterOperator.GREATER_THAN, label: 'greater than', types: ['number', 'date'] },
+    { value: FilterOperator.GREATER_OR_EQUAL, label: 'greater or equal', types: ['number', 'date'] },
+    { value: FilterOperator.LESS_THAN, label: 'less than', types: ['number', 'date'] },
+    { value: FilterOperator.LESS_OR_EQUAL, label: 'less or equal', types: ['number', 'date'] },
+    { value: FilterOperator.IN, label: 'in list', types: ['string', 'number'] },
+    { value: FilterOperator.NOT_IN, label: 'not in list', types: ['string', 'number'] },
+    { value: FilterOperator.LIKE, label: 'contains', types: ['string'] },
+    { value: FilterOperator.IS_NULL, label: 'is empty', types: ['any'], requiresValue: false },
+    { value: FilterOperator.IS_NOT_NULL, label: 'is not empty', types: ['any'], requiresValue: false },
+];
+/**
+ * Database type options with metadata
+ */
+export const DATABASE_TYPES = [
+    { value: 'postgresql', label: 'PostgreSQL', icon: 'database', defaultPort: 5432 },
+    { value: 'mysql', label: 'MySQL', icon: 'database', defaultPort: 3306 },
+    { value: 'mongodb', label: 'MongoDB', icon: 'database', defaultPort: 27017 },
+    { value: 'sqlite', label: 'SQLite', icon: 'database', defaultPort: 0 },
+    { value: 'mssql', label: 'SQL Server', icon: 'database', defaultPort: 1433 },
+    { value: 'oracle', label: 'Oracle', icon: 'database', defaultPort: 1521 },
+];
+/**
+ * Default configuration for Data nodes
+ */
+export const DEFAULT_DATA_NODE_CONFIG = {
+    operation: DataOperation.QUERY,
+    connectionPath: null,
+    dbType: null,
+    schema: null,
+    dataSource: null,
+    entity: null,
+    filter: null,
+    fields: {},
+    select: [],
+    orderBy: [],
+    limit: null,
+    offset: null,
+    outputVariable: 'results',
+};
+/**
+ * Available operations with metadata
+ */
+export const DATA_OPERATIONS = [
+    { value: DataOperation.QUERY, label: 'Query', icon: 'search', description: 'Fetch records' },
+    { value: DataOperation.INSERT, label: 'Insert', icon: 'plus', description: 'Create record' },
+    { value: DataOperation.UPDATE, label: 'Update', icon: 'edit', description: 'Modify records' },
+    { value: DataOperation.DELETE, label: 'Delete', icon: 'trash', description: 'Remove records' },
+];
+/**
+ * Data node configuration sections
+ */
+export const DATA_NODE_SECTIONS = [
+    { id: 'basic', title: 'Basic' },
+    { id: 'filter', title: 'Filter', description: 'Define conditions to filter records', showWhen: { operation: [DataOperation.QUERY, DataOperation.UPDATE, DataOperation.DELETE] } },
+    { id: 'fields', title: 'Fields', showWhen: { operation: [DataOperation.INSERT, DataOperation.UPDATE] } },
+    { id: 'select', title: 'Select Fields', showWhen: { operation: [DataOperation.QUERY] } },
+    { id: 'sorting', title: 'Sorting', showWhen: { operation: [DataOperation.QUERY] } },
+    { id: 'pagination', title: 'Pagination', showWhen: { operation: [DataOperation.QUERY] } },
+    { id: 'output', title: 'Output' },
+];
+/**
+ * Check if a section should be shown based on operation
+ */
+export function shouldShowSection(section, operation) {
+    if (!section.showWhen)
+        return true;
+    return section.showWhen.operation.includes(operation);
+}
+export function validateDataNodeConfig(config) {
+    const errors = [];
+    if (!config.operation) {
+        errors.push({ field: 'operation', message: 'Operation is required' });
+    }
+    // Check for new connectionPath or legacy dataSource
+    if (!config.connectionPath && !config.dataSource) {
+        errors.push({ field: 'connectionPath', message: 'Database connection is required' });
+    }
+    if (!config.entity) {
+        errors.push({ field: 'entity', message: 'Table/collection is required' });
+    }
+    if ((config.operation === DataOperation.INSERT || config.operation === DataOperation.UPDATE) &&
+        Object.keys(config.fields).length === 0) {
+        errors.push({ field: 'fields', message: 'At least one field is required' });
+    }
+    if (config.operation === DataOperation.DELETE && !config.filter) {
+        errors.push({ field: 'filter', message: 'Filter is required for DELETE (safety)' });
+    }
+    return errors;
+}
+/**
+ * Generate preview text for Data node
+ */
+export function generateDataNodePreview(config) {
+    if (!config.operation || !config.entity) {
+        return 'Configure data operation';
+    }
+    switch (config.operation) {
+        case DataOperation.QUERY:
+            return `Query from ${config.entity}`;
+        case DataOperation.INSERT:
+            return `Insert into ${config.entity}`;
+        case DataOperation.UPDATE:
+            return `Update ${config.entity}`;
+        case DataOperation.DELETE:
+            return `Delete from ${config.entity}`;
+        default:
+            return `${config.operation} ${config.entity}`;
+    }
+}
+//# sourceMappingURL=data-node.types.js.map

package/dist/src/components/canvas/data-node/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export * from './data-node.types.js';
+export * from './data-node-fields.component.js';
+export { dataNodeFieldStyles } from './data-node-fields.style.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/canvas/data-node/index.js

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+// Export types
+export * from './data-node.types.js';
+// Export components
+export * from './data-node-fields.component.js';
+// Export styles
+export { dataNodeFieldStyles } from './data-node-fields.style.js';
+//# sourceMappingURL=index.js.map

package/dist/src/components/canvas/data-node/schema-select.component.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+import { LitElement } from 'lit';
+import type { DatabaseProvider } from './data-node.types.js';
+/**
+ * Schema Select Component for Data Node configuration
+ *
+ * @fires value-change - Fired when selection changes
+ */
+export declare class NrSchemaSelect extends LitElement {
+    static styles: import("lit").CSSResult;
+    connectionPath: string;
+    value: string;
+    placeholder: string;
+    disabled: boolean;
+    applicationId: string;
+    databaseProvider?: DatabaseProvider;
+    private schemas;
+    private loading;
+    private error;
+    connectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    private loadSchemas;
+    private handleSelectChange;
+    private dispatchValueChange;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nr-schema-select': NrSchemaSelect;
+    }
+}
+//# sourceMappingURL=schema-select.component.d.ts.map

package/dist/src/components/canvas/data-node/schema-select.component.js

@@ -0,0 +1,196 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LitElement, html, css } from 'lit';
+import { property, customElement, state } from 'lit/decorators.js';
+/**
+ * Schema Select Component for Data Node configuration
+ *
+ * @fires value-change - Fired when selection changes
+ */
+let NrSchemaSelect = class NrSchemaSelect extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.connectionPath = '';
+        this.value = '';
+        this.placeholder = 'Select schema...';
+        this.disabled = false;
+        this.applicationId = '';
+        this.schemas = [];
+        this.loading = false;
+        // @ts-ignore - Reserved for future error display
+        this.error = '';
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.connectionPath)
+            this.loadSchemas();
+    }
+    updated(changedProperties) {
+        if (changedProperties.has('connectionPath')) {
+            const oldPath = changedProperties.get('connectionPath');
+            if (oldPath !== this.connectionPath) {
+                if (oldPath) {
+                    this.value = '';
+                    this.dispatchValueChange('');
+                }
+                this.loadSchemas();
+            }
+        }
+    }
+    loadSchemas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.applicationId || !this.connectionPath || !this.databaseProvider) {
+                this.schemas = [];
+                return;
+            }
+            this.loading = true;
+            this.error = '';
+            try {
+                const schemas = yield this.databaseProvider.getSchemas(this.connectionPath, this.applicationId);
+                this.schemas = schemas;
+                // Auto-select 'public' for PostgreSQL if available
+                if (!this.value && schemas.length > 0) {
+                    const publicSchema = schemas.find((s) => s.name === 'public');
+                    if (publicSchema) {
+                        this.value = 'public';
+                        this.dispatchValueChange('public');
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Failed to load schemas:', err);
+                this.error = err.message || 'Failed to load schemas';
+                this.schemas = [];
+            }
+            this.loading = false;
+        });
+    }
+    handleSelectChange(e) {
+        var _a;
+        const value = ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.value) || '';
+        this.value = value;
+        this.dispatchValueChange(value);
+    }
+    dispatchValueChange(value) {
+        this.dispatchEvent(new CustomEvent('value-change', {
+            detail: { value },
+            bubbles: true,
+            composed: true
+        }));
+    }
+    render() {
+        if (!this.connectionPath) {
+            return html `
+        <nr-select .options=${[]} placeholder="Select connection first..." ?disabled=${true}></nr-select>
+      `;
+        }
+        if (this.loading) {
+            return html `
+        <nr-select .options=${[]} placeholder="Loading schemas..." ?disabled=${true}>
+          <div slot="before-options" class="loading-state">
+            <div class="spinner"></div>
+            <span>Loading schemas...</span>
+          </div>
+        </nr-select>
+      `;
+        }
+        const options = this.schemas.map(schema => ({
+            label: schema.name,
+            value: schema.name,
+            description: schema.tableCount > 0 ? `${schema.tableCount} tables` : undefined
+        }));
+        return html `
+      <nr-select
+        .value=${this.value}
+        .options=${options}
+        placeholder=${this.placeholder}
+        ?disabled=${this.disabled}
+        .noOptionsMessage=${'No schemas found'}
+        @nr-change=${this.handleSelectChange}
+      ></nr-select>
+    `;
+    }
+};
+NrSchemaSelect.styles = css `
+    :host {
+      display: block;
+    }
+
+    .loading-state {
+      padding: 8px 12px;
+      color: var(--text-secondary, #6b7280);
+      font-size: 13px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .error-state {
+      padding: 8px 12px;
+      color: #dc2626;
+      font-size: 12px;
+    }
+
+    .spinner {
+      width: 14px;
+      height: 14px;
+      border: 2px solid var(--border-color, #e5e7eb);
+      border-top-color: var(--primary-color, #6366f1);
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  `;
+__decorate([
+    property({ type: String })
+], NrSchemaSelect.prototype, "connectionPath", void 0);
+__decorate([
+    property({ type: String })
+], NrSchemaSelect.prototype, "value", void 0);
+__decorate([
+    property({ type: String })
+], NrSchemaSelect.prototype, "placeholder", void 0);
+__decorate([
+    property({ type: Boolean })
+], NrSchemaSelect.prototype, "disabled", void 0);
+__decorate([
+    property({ type: String })
+], NrSchemaSelect.prototype, "applicationId", void 0);
+__decorate([
+    property({ attribute: false })
+], NrSchemaSelect.prototype, "databaseProvider", void 0);
+__decorate([
+    state()
+], NrSchemaSelect.prototype, "schemas", void 0);
+__decorate([
+    state()
+], NrSchemaSelect.prototype, "loading", void 0);
+__decorate([
+    state()
+], NrSchemaSelect.prototype, "error", void 0);
+NrSchemaSelect = __decorate([
+    customElement('nr-schema-select')
+], NrSchemaSelect);
+export { NrSchemaSelect };
+//# sourceMappingURL=schema-select.component.js.map

package/dist/src/components/canvas/data-node/table-select.component.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+import { LitElement } from 'lit';
+import type { DatabaseProvider } from './data-node.types.js';
+/**
+ * Table Select Component for Data Node configuration
+ *
+ * @fires value-change - Fired when selection changes
+ */
+export declare class NrTableSelect extends LitElement {
+    static styles: import("lit").CSSResult;
+    connectionPath: string;
+    schema: string;
+    value: string;
+    placeholder: string;
+    disabled: boolean;
+    applicationId: string;
+    databaseProvider?: DatabaseProvider;
+    private tables;
+    private loading;
+    private error;
+    connectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    private loadTables;
+    private handleSelectChange;
+    private dispatchValueChange;
+    private getTableTypeLabel;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nr-table-select': NrTableSelect;
+    }
+}
+//# sourceMappingURL=table-select.component.d.ts.map

package/dist/src/components/canvas/data-node/table-select.component.js

@@ -0,0 +1,199 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LitElement, html, css } from 'lit';
+import { property, customElement, state } from 'lit/decorators.js';
+/**
+ * Table Select Component for Data Node configuration
+ *
+ * @fires value-change - Fired when selection changes
+ */
+let NrTableSelect = class NrTableSelect extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.connectionPath = '';
+        this.schema = '';
+        this.value = '';
+        this.placeholder = 'Select table...';
+        this.disabled = false;
+        this.applicationId = '';
+        this.tables = [];
+        this.loading = false;
+        // @ts-ignore - Reserved for future error display
+        this.error = '';
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.connectionPath)
+            this.loadTables();
+    }
+    updated(changedProperties) {
+        const connectionChanged = changedProperties.has('connectionPath');
+        const schemaChanged = changedProperties.has('schema');
+        if (connectionChanged || schemaChanged) {
+            const oldPath = changedProperties.get('connectionPath');
+            const oldSchema = changedProperties.get('schema');
+            if ((connectionChanged && oldPath !== undefined && oldPath !== this.connectionPath) ||
+                (schemaChanged && oldSchema !== undefined && oldSchema !== this.schema)) {
+                this.value = '';
+                this.dispatchValueChange('');
+            }
+            this.loadTables();
+        }
+    }
+    loadTables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.applicationId || !this.connectionPath || !this.databaseProvider) {
+                this.tables = [];
+                return;
+            }
+            this.loading = true;
+            this.error = '';
+            try {
+                const tables = yield this.databaseProvider.getTables(this.connectionPath, this.applicationId, this.schema || undefined);
+                this.tables = tables;
+            }
+            catch (err) {
+                console.error('Failed to load tables:', err);
+                this.error = err.message || 'Failed to load tables';
+                this.tables = [];
+            }
+            this.loading = false;
+        });
+    }
+    handleSelectChange(e) {
+        var _a;
+        const value = ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.value) || '';
+        this.value = value;
+        this.dispatchValueChange(value);
+    }
+    dispatchValueChange(value) {
+        this.dispatchEvent(new CustomEvent('value-change', {
+            detail: { value },
+            bubbles: true,
+            composed: true
+        }));
+    }
+    getTableTypeLabel(type) {
+        return type === 'view' ? 'View' : type === 'collection' ? 'Collection' : 'Table';
+    }
+    render() {
+        if (!this.connectionPath) {
+            return html `
+        <nr-select .options=${[]} placeholder="Select connection first..." ?disabled=${true}></nr-select>
+      `;
+        }
+        if (this.loading) {
+            return html `
+        <nr-select .options=${[]} placeholder="Loading tables..." ?disabled=${true}>
+          <div slot="before-options" class="loading-state">
+            <div class="spinner"></div>
+            <span>Loading tables...</span>
+          </div>
+        </nr-select>
+      `;
+        }
+        const options = this.tables.map(table => ({
+            label: table.name,
+            value: table.name,
+            description: this.getTableTypeLabel(table.type),
+            icon: table.type === 'view' ? 'eye' : 'table'
+        }));
+        return html `
+      <nr-select
+        .value=${this.value}
+        .options=${options}
+        placeholder=${this.placeholder}
+        ?disabled=${this.disabled}
+        .noOptionsMessage=${'No tables found'}
+        searchable
+        @nr-change=${this.handleSelectChange}
+      ></nr-select>
+    `;
+    }
+};
+NrTableSelect.styles = css `
+    :host {
+      display: block;
+    }
+
+    .loading-state {
+      padding: 8px 12px;
+      color: var(--text-secondary, #6b7280);
+      font-size: 13px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .error-state {
+      padding: 8px 12px;
+      color: #dc2626;
+      font-size: 12px;
+    }
+
+    .spinner {
+      width: 14px;
+      height: 14px;
+      border: 2px solid var(--border-color, #e5e7eb);
+      border-top-color: var(--primary-color, #6366f1);
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  `;
+__decorate([
+    property({ type: String })
+], NrTableSelect.prototype, "connectionPath", void 0);
+__decorate([
+    property({ type: String })
+], NrTableSelect.prototype, "schema", void 0);
+__decorate([
+    property({ type: String })
+], NrTableSelect.prototype, "value", void 0);
+__decorate([
+    property({ type: String })
+], NrTableSelect.prototype, "placeholder", void 0);
+__decorate([
+    property({ type: Boolean })
+], NrTableSelect.prototype, "disabled", void 0);
+__decorate([
+    property({ type: String })
+], NrTableSelect.prototype, "applicationId", void 0);
+__decorate([
+    property({ attribute: false })
+], NrTableSelect.prototype, "databaseProvider", void 0);
+__decorate([
+    state()
+], NrTableSelect.prototype, "tables", void 0);
+__decorate([
+    state()
+], NrTableSelect.prototype, "loading", void 0);
+__decorate([
+    state()
+], NrTableSelect.prototype, "error", void 0);
+NrTableSelect = __decorate([
+    customElement('nr-table-select')
+], NrTableSelect);
+export { NrTableSelect };
+//# sourceMappingURL=table-select.component.js.map

package/dist/src/components/canvas/index.d.ts

@@ -4,6 +4,8 @@ export * from './canvas.constants.js';
 export * from './workflow-canvas.types.js';
 export * from './workflow-node.component.js';
 export * from './workflow-canvas.component.js';
+export * from './whiteboard-node.component.js';
+export * from './whiteboard-canvas.component.js';
 export { DataOperation, DATA_OPERATIONS, FilterOperator, FILTER_OPERATORS, DEFAULT_DATA_NODE_CONFIG, DATA_NODE_SECTIONS, DATA_OPERATIONS as DataOperations, validateDataNodeConfig, shouldShowSection, } from './data-node/data-node.types.js';
 export { dataNodeFieldStyles } from './data-node/data-node-fields.style.js';
 export * from './data-node/data-node-fields.component.js';

package/dist/src/components/canvas/index.js

@@ -8,6 +8,9 @@ export * from './canvas.constants.js';
 export * from './workflow-canvas.types.js';
 export * from './workflow-node.component.js';
 export * from './workflow-canvas.component.js';
+// Whiteboard canvas components
+export * from './whiteboard-node.component.js';
+export * from './whiteboard-canvas.component.js';
 // Data node components and types - re-export runtime values only
 // Types should be imported directly from './data-node/data-node.types.js' when needed
 export { DataOperation, DATA_OPERATIONS, FilterOperator, FILTER_OPERATORS, DEFAULT_DATA_NODE_CONFIG, DATA_NODE_SECTIONS, DATA_OPERATIONS as DataOperations, validateDataNodeConfig, shouldShowSection, } from './data-node/data-node.types.js';