bways-report 0.1.0

package/esm2022/lib/features/designer/services/designer-state.service.mjs

@@ -0,0 +1,310 @@
+import { computed, inject, Injectable, signal } from '@angular/core';
+import { ComponentRegistry } from '../../../core/registry/component-registry';
+import { generateId } from '../../../core/utilities/id-generator';
+import * as i0 from "@angular/core";
+const MAX_HISTORY = 30;
+/**
+ * DesignerStateService coordinates state for the visual report designer.
+ *
+ * Scoped at the Designer component level (not root) to ensure multiple designer
+ * instances or navigation flows remain strictly isolated.
+ */
+export class DesignerStateService {
+    registry = inject(ComponentRegistry);
+    /** Current active report definition */
+    definition = signal({
+        id: generateId('rpt'),
+        name: 'Untitled Report',
+        schemaVersion: 1,
+        version: 1,
+        layout: { columns: 12, gap: 16, padding: 24, direction: 'ltr' },
+        components: [],
+        parameters: [],
+        dataSources: [],
+    });
+    /** Selected component ID in canvas */
+    selectedComponentId = signal(null);
+    /** Active property editor tab */
+    activeTab = signal('properties');
+    /** Current view mode (design, preview, or raw json) */
+    viewMode = signal('design');
+    /** Dirty flag indicating unsaved changes */
+    isDirty = signal(false);
+    // History stack for Undo / Redo
+    history = signal([]);
+    historyIndex = signal(-1);
+    canUndo = computed(() => this.historyIndex() > 0);
+    canRedo = computed(() => this.historyIndex() >= 0 && this.historyIndex() < this.history().length - 1);
+    /** Currently selected component instance, or null if none */
+    selectedComponent = computed(() => {
+        const id = this.selectedComponentId();
+        if (!id)
+            return null;
+        return this.definition().components.find((c) => c.id === id) ?? null;
+    });
+    /**
+     * Initializes or reloads a report definition into the designer.
+     */
+    loadDefinition(def) {
+        const cloned = JSON.parse(JSON.stringify(def));
+        this.definition.set(cloned);
+        this.selectedComponentId.set(null);
+        this.isDirty.set(false);
+        this.history.set([JSON.parse(JSON.stringify(cloned))]);
+        this.historyIndex.set(0);
+    }
+    /**
+     * Selects a component for property editing.
+     */
+    selectComponent(id) {
+        this.selectedComponentId.set(id);
+        if (id) {
+            this.activeTab.set('properties');
+        }
+    }
+    /**
+     * Sets the active view mode (design, live preview, json schema).
+     */
+    setViewMode(mode) {
+        this.viewMode.set(mode);
+    }
+    /**
+     * Sets the active editor tab.
+     */
+    setActiveTab(tab) {
+        this.activeTab.set(tab);
+    }
+    /**
+     * Adds a new component of the specified type onto the canvas.
+     */
+    addComponent(type, targetIndex) {
+        const meta = this.registry.resolve(type);
+        const defaultConfig = meta?.createDefaultConfig() ?? {
+            id: generateId(type),
+            type,
+            label: meta?.displayName ?? type,
+            key: `${type}_${Math.random().toString(36).substring(2, 6)}`,
+        };
+        const newComponent = {
+            id: generateId(type),
+            type,
+            label: defaultConfig.label ?? meta?.displayName ?? type,
+            key: defaultConfig.key ?? `${type}_${Math.random().toString(36).substring(2, 6)}`,
+            order: 0,
+            layout: {
+                columnSpan: defaultConfig.layout?.columnSpan ?? (type === 'button' ? 2 : 4),
+                ...defaultConfig.layout,
+            },
+            properties: { ...(defaultConfig.properties ?? {}) },
+            validation: defaultConfig.validation ? { ...defaultConfig.validation } : undefined,
+            dataSource: defaultConfig.dataSource ? { ...defaultConfig.dataSource } : undefined,
+            enabled: defaultConfig.enabled ?? true,
+        };
+        const currentComponents = [...this.definition().components].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        if (targetIndex !== undefined && targetIndex >= 0 && targetIndex <= currentComponents.length) {
+            currentComponents.splice(targetIndex, 0, newComponent);
+        }
+        else {
+            currentComponents.push(newComponent);
+        }
+        // Recalculate order indices
+        currentComponents.forEach((c, idx) => (c.order = idx + 1));
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+        this.selectComponent(newComponent.id);
+        return newComponent;
+    }
+    /**
+     * Removes a component by its ID.
+     */
+    removeComponent(id) {
+        const currentComponents = this.definition().components.filter((c) => c.id !== id);
+        currentComponents.forEach((c, idx) => (c.order = idx + 1));
+        if (this.selectedComponentId() === id) {
+            this.selectedComponentId.set(null);
+        }
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+    }
+    /**
+     * Duplicates an existing component.
+     */
+    duplicateComponent(id) {
+        const existing = this.definition().components.find((c) => c.id === id);
+        if (!existing)
+            return null;
+        const duplicated = {
+            ...JSON.parse(JSON.stringify(existing)),
+            id: generateId(existing.type),
+            key: existing.key ? `${existing.key}_copy` : undefined,
+            label: existing.label ? `${existing.label} (Copy)` : undefined,
+        };
+        const currentComponents = [...this.definition().components].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        const index = currentComponents.findIndex((c) => c.id === id);
+        currentComponents.splice(index + 1, 0, duplicated);
+        currentComponents.forEach((c, idx) => (c.order = idx + 1));
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+        this.selectComponent(duplicated.id);
+        return duplicated;
+    }
+    /**
+     * Moves a component from previous index to current index (e.g. from CDK drag drop).
+     */
+    moveComponent(previousIndex, currentIndex) {
+        if (previousIndex === currentIndex)
+            return;
+        const currentComponents = [...this.definition().components].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        if (previousIndex < 0 || previousIndex >= currentComponents.length)
+            return;
+        const targetIdx = Math.max(0, Math.min(currentIndex, currentComponents.length - 1));
+        const [moved] = currentComponents.splice(previousIndex, 1);
+        currentComponents.splice(targetIdx, 0, moved);
+        currentComponents.forEach((c, idx) => (c.order = idx + 1));
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+    }
+    /**
+     * Updates partial properties of a component.
+     */
+    updateComponent(id, updates) {
+        const currentComponents = this.definition().components.map((c) => {
+            if (c.id === id) {
+                return { ...c, ...updates };
+            }
+            return c;
+        });
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+    }
+    /**
+     * Updates a single component property value within `properties`.
+     */
+    updateComponentProperty(id, propKey, value) {
+        const currentComponents = this.definition().components.map((c) => {
+            if (c.id === id) {
+                return {
+                    ...c,
+                    properties: {
+                        ...(c.properties ?? {}),
+                        [propKey]: value,
+                    },
+                };
+            }
+            return c;
+        });
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+    }
+    /**
+     * Updates layout properties for a component (e.g. columnSpan).
+     */
+    updateComponentLayout(id, layout) {
+        const currentComponents = this.definition().components.map((c) => {
+            if (c.id === id) {
+                const nextLayout = {
+                    ...(c.layout ?? {}),
+                    ...layout,
+                };
+                for (const key of Object.keys(layout)) {
+                    if (layout[key] === undefined) {
+                        delete nextLayout[key];
+                    }
+                }
+                return {
+                    ...c,
+                    layout: nextLayout,
+                };
+            }
+            return c;
+        });
+        this.mutateDefinition((def) => ({
+            ...def,
+            components: currentComponents,
+        }));
+    }
+    /**
+     * Updates report-level settings (name, description, layout).
+     */
+    updateReportSettings(settings) {
+        this.mutateDefinition((def) => ({
+            ...def,
+            ...settings,
+        }));
+    }
+    /**
+     * Updates grid definition settings.
+     */
+    updateGridSettings(grid) {
+        this.mutateDefinition((def) => ({
+            ...def,
+            grid,
+        }));
+    }
+    /**
+     * Reverts to the previous state in history.
+     */
+    undo() {
+        if (!this.canUndo())
+            return;
+        const newIndex = this.historyIndex() - 1;
+        this.historyIndex.set(newIndex);
+        const restored = JSON.parse(JSON.stringify(this.history()[newIndex]));
+        this.definition.set(restored);
+        this.isDirty.set(true);
+    }
+    /**
+     * Advances to the next state in history.
+     */
+    redo() {
+        if (!this.canRedo())
+            return;
+        const newIndex = this.historyIndex() + 1;
+        this.historyIndex.set(newIndex);
+        const restored = JSON.parse(JSON.stringify(this.history()[newIndex]));
+        this.definition.set(restored);
+        this.isDirty.set(true);
+    }
+    /**
+     * Marks the current definition state as saved.
+     */
+    markSaved() {
+        this.isDirty.set(false);
+    }
+    /**
+     * Applies an immutable state change and pushes to history.
+     */
+    mutateDefinition(updater) {
+        const next = updater(this.definition());
+        this.definition.set(next);
+        this.isDirty.set(true);
+        this.pushHistory(next);
+    }
+    pushHistory(def) {
+        const currentHist = this.history().slice(0, this.historyIndex() + 1);
+        currentHist.push(JSON.parse(JSON.stringify(def)));
+        if (currentHist.length > MAX_HISTORY) {
+            currentHist.shift();
+        }
+        this.history.set(currentHist);
+        this.historyIndex.set(currentHist.length - 1);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DesignerStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DesignerStateService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DesignerStateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"designer-state.service.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/designer/services/designer-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, inject, Injectable, signal } from '@angular/core';\nimport { ReportDefinition } from '../../../core/models/report-definition.model';\nimport { ReportComponentDefinition } from '../../../core/models/report-component.model';\nimport { ComponentLayoutDefinition } from '../../../core/models/report-layout.model';\nimport { ReportGridDefinition } from '../../../core/models/report-grid.model';\nimport { ComponentRegistry } from '../../../core/registry/component-registry';\nimport { generateId } from '../../../core/utilities/id-generator';\n\nexport type DesignerViewMode = 'design' | 'preview' | 'json';\nexport type DesignerActiveTab = 'properties' | 'report' | 'grid';\n\nconst MAX_HISTORY = 30;\n\n/**\n * DesignerStateService coordinates state for the visual report designer.\n *\n * Scoped at the Designer component level (not root) to ensure multiple designer\n * instances or navigation flows remain strictly isolated.\n */\n@Injectable()\nexport class DesignerStateService {\n  private readonly registry = inject(ComponentRegistry);\n\n  /** Current active report definition */\n  readonly definition = signal<ReportDefinition>({\n    id: generateId('rpt'),\n    name: 'Untitled Report',\n    schemaVersion: 1,\n    version: 1,\n    layout: { columns: 12, gap: 16, padding: 24, direction: 'ltr' },\n    components: [],\n    parameters: [],\n    dataSources: [],\n  });\n\n  /** Selected component ID in canvas */\n  readonly selectedComponentId = signal<string | null>(null);\n\n  /** Active property editor tab */\n  readonly activeTab = signal<DesignerActiveTab>('properties');\n\n  /** Current view mode (design, preview, or raw json) */\n  readonly viewMode = signal<DesignerViewMode>('design');\n\n  /** Dirty flag indicating unsaved changes */\n  readonly isDirty = signal<boolean>(false);\n\n  // History stack for Undo / Redo\n  private readonly history = signal<ReportDefinition[]>([]);\n  private readonly historyIndex = signal<number>(-1);\n\n  readonly canUndo = computed(() => this.historyIndex() > 0);\n  readonly canRedo = computed(() => this.historyIndex() >= 0 && this.historyIndex() < this.history().length - 1);\n\n  /** Currently selected component instance, or null if none */\n  readonly selectedComponent = computed<ReportComponentDefinition | null>(() => {\n    const id = this.selectedComponentId();\n    if (!id) return null;\n    return this.definition().components.find((c) => c.id === id) ?? null;\n  });\n\n  /**\n   * Initializes or reloads a report definition into the designer.\n   */\n  loadDefinition(def: ReportDefinition): void {\n    const cloned = JSON.parse(JSON.stringify(def)) as ReportDefinition;\n    this.definition.set(cloned);\n    this.selectedComponentId.set(null);\n    this.isDirty.set(false);\n    this.history.set([JSON.parse(JSON.stringify(cloned))]);\n    this.historyIndex.set(0);\n  }\n\n  /**\n   * Selects a component for property editing.\n   */\n  selectComponent(id: string | null): void {\n    this.selectedComponentId.set(id);\n    if (id) {\n      this.activeTab.set('properties');\n    }\n  }\n\n  /**\n   * Sets the active view mode (design, live preview, json schema).\n   */\n  setViewMode(mode: DesignerViewMode): void {\n    this.viewMode.set(mode);\n  }\n\n  /**\n   * Sets the active editor tab.\n   */\n  setActiveTab(tab: DesignerActiveTab): void {\n    this.activeTab.set(tab);\n  }\n\n  /**\n   * Adds a new component of the specified type onto the canvas.\n   */\n  addComponent(type: string, targetIndex?: number): ReportComponentDefinition {\n    const meta = this.registry.resolve(type);\n    const defaultConfig = meta?.createDefaultConfig() ?? {\n      id: generateId(type),\n      type,\n      label: meta?.displayName ?? type,\n      key: `${type}_${Math.random().toString(36).substring(2, 6)}`,\n    };\n\n    const newComponent: ReportComponentDefinition = {\n      id: generateId(type),\n      type,\n      label: defaultConfig.label ?? meta?.displayName ?? type,\n      key: defaultConfig.key ?? `${type}_${Math.random().toString(36).substring(2, 6)}`,\n      order: 0,\n      layout: {\n        columnSpan: defaultConfig.layout?.columnSpan ?? (type === 'button' ? 2 : 4),\n        ...defaultConfig.layout,\n      },\n      properties: { ...(defaultConfig.properties ?? {}) },\n      validation: defaultConfig.validation ? { ...defaultConfig.validation } : undefined,\n      dataSource: defaultConfig.dataSource ? { ...defaultConfig.dataSource } : undefined,\n      enabled: defaultConfig.enabled ?? true,\n    };\n\n    const currentComponents = [...this.definition().components].sort(\n      (a, b) => (a.order ?? 0) - (b.order ?? 0)\n    );\n    if (targetIndex !== undefined && targetIndex >= 0 && targetIndex <= currentComponents.length) {\n      currentComponents.splice(targetIndex, 0, newComponent);\n    } else {\n      currentComponents.push(newComponent);\n    }\n\n    // Recalculate order indices\n    currentComponents.forEach((c, idx) => (c.order = idx + 1));\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n\n    this.selectComponent(newComponent.id);\n    return newComponent;\n  }\n\n  /**\n   * Removes a component by its ID.\n   */\n  removeComponent(id: string): void {\n    const currentComponents = this.definition().components.filter((c) => c.id !== id);\n    currentComponents.forEach((c, idx) => (c.order = idx + 1));\n\n    if (this.selectedComponentId() === id) {\n      this.selectedComponentId.set(null);\n    }\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n  }\n\n  /**\n   * Duplicates an existing component.\n   */\n  duplicateComponent(id: string): ReportComponentDefinition | null {\n    const existing = this.definition().components.find((c) => c.id === id);\n    if (!existing) return null;\n\n    const duplicated: ReportComponentDefinition = {\n      ...JSON.parse(JSON.stringify(existing)),\n      id: generateId(existing.type),\n      key: existing.key ? `${existing.key}_copy` : undefined,\n      label: existing.label ? `${existing.label} (Copy)` : undefined,\n    };\n\n    const currentComponents = [...this.definition().components].sort(\n      (a, b) => (a.order ?? 0) - (b.order ?? 0)\n    );\n    const index = currentComponents.findIndex((c) => c.id === id);\n    currentComponents.splice(index + 1, 0, duplicated);\n    currentComponents.forEach((c, idx) => (c.order = idx + 1));\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n\n    this.selectComponent(duplicated.id);\n    return duplicated;\n  }\n\n  /**\n   * Moves a component from previous index to current index (e.g. from CDK drag drop).\n   */\n  moveComponent(previousIndex: number, currentIndex: number): void {\n    if (previousIndex === currentIndex) return;\n\n    const currentComponents = [...this.definition().components].sort(\n      (a, b) => (a.order ?? 0) - (b.order ?? 0)\n    );\n    if (previousIndex < 0 || previousIndex >= currentComponents.length) return;\n    const targetIdx = Math.max(0, Math.min(currentIndex, currentComponents.length - 1));\n\n    const [moved] = currentComponents.splice(previousIndex, 1);\n    currentComponents.splice(targetIdx, 0, moved);\n    currentComponents.forEach((c, idx) => (c.order = idx + 1));\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n  }\n\n  /**\n   * Updates partial properties of a component.\n   */\n  updateComponent(id: string, updates: Partial<ReportComponentDefinition>): void {\n    const currentComponents = this.definition().components.map((c) => {\n      if (c.id === id) {\n        return { ...c, ...updates };\n      }\n      return c;\n    });\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n  }\n\n  /**\n   * Updates a single component property value within `properties`.\n   */\n  updateComponentProperty(id: string, propKey: string, value: unknown): void {\n    const currentComponents = this.definition().components.map((c) => {\n      if (c.id === id) {\n        return {\n          ...c,\n          properties: {\n            ...(c.properties ?? {}),\n            [propKey]: value,\n          },\n        };\n      }\n      return c;\n    });\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n  }\n\n  /**\n   * Updates layout properties for a component (e.g. columnSpan).\n   */\n  updateComponentLayout(id: string, layout: Partial<ComponentLayoutDefinition>): void {\n    const currentComponents = this.definition().components.map((c) => {\n      if (c.id === id) {\n        const nextLayout = {\n          ...(c.layout ?? {}),\n          ...layout,\n        };\n        for (const key of Object.keys(layout) as (keyof ComponentLayoutDefinition)[]) {\n          if (layout[key] === undefined) {\n            delete nextLayout[key];\n          }\n        }\n        return {\n          ...c,\n          layout: nextLayout,\n        };\n      }\n      return c;\n    });\n\n    this.mutateDefinition((def) => ({\n      ...def,\n      components: currentComponents,\n    }));\n  }\n\n  /**\n   * Updates report-level settings (name, description, layout).\n   */\n  updateReportSettings(settings: Partial<ReportDefinition>): void {\n    this.mutateDefinition((def) => ({\n      ...def,\n      ...settings,\n    }));\n  }\n\n  /**\n   * Updates grid definition settings.\n   */\n  updateGridSettings(grid: ReportGridDefinition | undefined): void {\n    this.mutateDefinition((def) => ({\n      ...def,\n      grid,\n    }));\n  }\n\n  /**\n   * Reverts to the previous state in history.\n   */\n  undo(): void {\n    if (!this.canUndo()) return;\n    const newIndex = this.historyIndex() - 1;\n    this.historyIndex.set(newIndex);\n    const restored = JSON.parse(JSON.stringify(this.history()[newIndex])) as ReportDefinition;\n    this.definition.set(restored);\n    this.isDirty.set(true);\n  }\n\n  /**\n   * Advances to the next state in history.\n   */\n  redo(): void {\n    if (!this.canRedo()) return;\n    const newIndex = this.historyIndex() + 1;\n    this.historyIndex.set(newIndex);\n    const restored = JSON.parse(JSON.stringify(this.history()[newIndex])) as ReportDefinition;\n    this.definition.set(restored);\n    this.isDirty.set(true);\n  }\n\n  /**\n   * Marks the current definition state as saved.\n   */\n  markSaved(): void {\n    this.isDirty.set(false);\n  }\n\n  /**\n   * Applies an immutable state change and pushes to history.\n   */\n  private mutateDefinition(updater: (current: ReportDefinition) => ReportDefinition): void {\n    const next = updater(this.definition());\n    this.definition.set(next);\n    this.isDirty.set(true);\n    this.pushHistory(next);\n  }\n\n  private pushHistory(def: ReportDefinition): void {\n    const currentHist = this.history().slice(0, this.historyIndex() + 1);\n    currentHist.push(JSON.parse(JSON.stringify(def)));\n    if (currentHist.length > MAX_HISTORY) {\n      currentHist.shift();\n    }\n    this.history.set(currentHist);\n    this.historyIndex.set(currentHist.length - 1);\n  }\n}\n"]}

package/esm2022/lib/features/designer/services/index.mjs

@@ -0,0 +1,2 @@
+export { DesignerStateService } from './designer-state.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9mZWF0dXJlcy9kZXNpZ25lci9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERlc2lnbmVyU3RhdGVTZXJ2aWNlIH0gZnJvbSAnLi9kZXNpZ25lci1zdGF0ZS5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgRGVzaWduZXJWaWV3TW9kZSxcbiAgRGVzaWduZXJBY3RpdmVUYWIsXG59IGZyb20gJy4vZGVzaWduZXItc3RhdGUuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/features/designer/utilities/canvas-layout.util.mjs

@@ -0,0 +1,124 @@
+/**
+ * Pure utility functions for design canvas layout, grid calculations, and sizing.
+ *
+ * Implemented as framework-independent pure functions per Rule 10 & 11 (Pure Logic First).
+ */
+/**
+ * Resolves the effective column span for a component.
+ * Uses layout.columnSpan if specified, otherwise defaults based on component type (e.g. 2 for button, 4 for others).
+ */
+export function resolveComponentSpan(comp, totalColumns = 12, overrideSpan) {
+    if (overrideSpan !== undefined && overrideSpan !== null) {
+        return Math.max(1, Math.min(totalColumns, overrideSpan));
+    }
+    const defaultSpan = comp.type === 'button' ? 2 : 4;
+    const rawSpan = comp.layout?.columnSpan ?? defaultSpan;
+    return Math.max(1, Math.min(totalColumns, rawSpan));
+}
+/**
+ * Computes the CSS `grid-column` specification string for a component.
+ */
+export function calculateGridColumn(comp, totalColumns = 12, span) {
+    const effectiveSpan = span ?? resolveComponentSpan(comp, totalColumns);
+    const clamped = Math.max(1, Math.min(effectiveSpan, totalColumns));
+    const col = comp.layout?.column;
+    if (col && col >= 1 && col <= totalColumns) {
+        return `${col} / span ${clamped}`;
+    }
+    return comp.layout?.newRow ? `1 / span ${clamped}` : `span ${clamped}`;
+}
+/**
+ * Computes the CSS `grid-row` specification string for a component.
+ */
+export function calculateGridRow(comp) {
+    const rowSpan = comp.layout?.rowSpan;
+    if (rowSpan && rowSpan > 1) {
+        return `span ${rowSpan}`;
+    }
+    return 'auto';
+}
+/**
+ * Overhead in pixels for the Visual Canvas card (card header 32px + card body vertical padding 16px).
+ * Adding this overhead to the component's logical height ensures that the canvas card body
+ * renders at the exact same pixel dimensions as the live preview component.
+ */
+export const CANVAS_CARD_OVERHEAD = 48;
+/**
+ * Resolves the CSS height property for the canvas component card.
+ * Accounts for the card header and padding overhead so the inner mock body
+ * accurately mirrors the runtime component height.
+ */
+export function resolveCanvasCardHeight(comp, overrideComponentHeight, overhead = CANVAS_CARD_OVERHEAD) {
+    if (overrideComponentHeight !== undefined && overrideComponentHeight !== null) {
+        return `${overrideComponentHeight + overhead}px`;
+    }
+    const h = comp.layout?.height;
+    if (!h || h === 'auto')
+        return 'auto';
+    const parsed = parseInt(h, 10);
+    return isNaN(parsed) ? h : `${parsed + overhead}px`;
+}
+/**
+ * Resolves the CSS min-height property for the canvas component card.
+ */
+export function resolveCanvasCardMinHeight(comp, overrideComponentHeight, overhead = CANVAS_CARD_OVERHEAD) {
+    if (overrideComponentHeight !== undefined && overrideComponentHeight !== null) {
+        return `${overrideComponentHeight + overhead}px`;
+    }
+    const minH = comp.layout?.minHeight;
+    if (!minH || minH === 'auto')
+        return 'auto';
+    const parsed = parseInt(minH, 10);
+    return isNaN(parsed) ? minH : `${parsed + overhead}px`;
+}
+/**
+ * Resolves the CSS height property for a runtime component.
+ */
+export function resolveComponentHeight(comp, overrideHeight) {
+    if (overrideHeight !== undefined && overrideHeight !== null) {
+        return `${overrideHeight}px`;
+    }
+    return comp.layout?.height || 'auto';
+}
+/**
+ * Resolves the CSS min-height property for a runtime component.
+ */
+export function resolveComponentMinHeight(comp, overrideHeight) {
+    if (overrideHeight !== undefined && overrideHeight !== null) {
+        return `${overrideHeight}px`;
+    }
+    return comp.layout?.minHeight || 'auto';
+}
+/**
+ * Calculates new snapped span given drag deltaX, column width, and grid gap.
+ */
+export function calculateSnappedSpan(deltaX, startSpan, colWidth, gap, totalCols) {
+    const step = colWidth + gap;
+    if (step <= 0)
+        return startSpan;
+    const spanDelta = Math.round(deltaX / step);
+    return Math.max(1, Math.min(totalCols, startSpan + spanDelta));
+}
+/**
+ * Calculates new height given drag deltaY and minimum height constraint.
+ */
+export function calculateSnappedHeight(deltaY, startHeight, minHeight = 50) {
+    return Math.max(minHeight, Math.round(startHeight + deltaY));
+}
+/**
+ * Maps component type to standard icon identifier.
+ */
+export function getComponentIconName(type) {
+    switch (type) {
+        case 'input': return 'text-fields';
+        case 'dropdown': return 'dropdown';
+        case 'date': return 'calendar';
+        case 'number': return 'number';
+        case 'checkbox': return 'checkbox';
+        case 'button': return 'button';
+        case 'kpi-card': return 'kpi';
+        case 'chart': return 'chart-bar';
+        default: return 'box';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canvas-layout.util.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/designer/utilities/canvas-layout.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReportComponentDefinition } from '../../../core/models/report-component.model';\n\n/**\n * Pure utility functions for design canvas layout, grid calculations, and sizing.\n *\n * Implemented as framework-independent pure functions per Rule 10 & 11 (Pure Logic First).\n */\n\n/**\n * Resolves the effective column span for a component.\n * Uses layout.columnSpan if specified, otherwise defaults based on component type (e.g. 2 for button, 4 for others).\n */\nexport function resolveComponentSpan(\n  comp: ReportComponentDefinition,\n  totalColumns: number = 12,\n  overrideSpan?: number | null\n): number {\n  if (overrideSpan !== undefined && overrideSpan !== null) {\n    return Math.max(1, Math.min(totalColumns, overrideSpan));\n  }\n  const defaultSpan = comp.type === 'button' ? 2 : 4;\n  const rawSpan = comp.layout?.columnSpan ?? defaultSpan;\n  return Math.max(1, Math.min(totalColumns, rawSpan));\n}\n\n/**\n * Computes the CSS `grid-column` specification string for a component.\n */\nexport function calculateGridColumn(\n  comp: ReportComponentDefinition,\n  totalColumns: number = 12,\n  span?: number\n): string {\n  const effectiveSpan = span ?? resolveComponentSpan(comp, totalColumns);\n  const clamped = Math.max(1, Math.min(effectiveSpan, totalColumns));\n  const col = comp.layout?.column;\n\n  if (col && col >= 1 && col <= totalColumns) {\n    return `${col} / span ${clamped}`;\n  }\n\n  return comp.layout?.newRow ? `1 / span ${clamped}` : `span ${clamped}`;\n}\n\n/**\n * Computes the CSS `grid-row` specification string for a component.\n */\nexport function calculateGridRow(comp: ReportComponentDefinition): string {\n  const rowSpan = comp.layout?.rowSpan;\n  if (rowSpan && rowSpan > 1) {\n    return `span ${rowSpan}`;\n  }\n  return 'auto';\n}\n\n/**\n * Overhead in pixels for the Visual Canvas card (card header 32px + card body vertical padding 16px).\n * Adding this overhead to the component's logical height ensures that the canvas card body\n * renders at the exact same pixel dimensions as the live preview component.\n */\nexport const CANVAS_CARD_OVERHEAD = 48;\n\n/**\n * Resolves the CSS height property for the canvas component card.\n * Accounts for the card header and padding overhead so the inner mock body\n * accurately mirrors the runtime component height.\n */\nexport function resolveCanvasCardHeight(\n  comp: ReportComponentDefinition,\n  overrideComponentHeight?: number | null,\n  overhead: number = CANVAS_CARD_OVERHEAD\n): string {\n  if (overrideComponentHeight !== undefined && overrideComponentHeight !== null) {\n    return `${overrideComponentHeight + overhead}px`;\n  }\n  const h = comp.layout?.height;\n  if (!h || h === 'auto') return 'auto';\n  const parsed = parseInt(h, 10);\n  return isNaN(parsed) ? h : `${parsed + overhead}px`;\n}\n\n/**\n * Resolves the CSS min-height property for the canvas component card.\n */\nexport function resolveCanvasCardMinHeight(\n  comp: ReportComponentDefinition,\n  overrideComponentHeight?: number | null,\n  overhead: number = CANVAS_CARD_OVERHEAD\n): string {\n  if (overrideComponentHeight !== undefined && overrideComponentHeight !== null) {\n    return `${overrideComponentHeight + overhead}px`;\n  }\n  const minH = comp.layout?.minHeight;\n  if (!minH || minH === 'auto') return 'auto';\n  const parsed = parseInt(minH, 10);\n  return isNaN(parsed) ? minH : `${parsed + overhead}px`;\n}\n\n/**\n * Resolves the CSS height property for a runtime component.\n */\nexport function resolveComponentHeight(\n  comp: ReportComponentDefinition,\n  overrideHeight?: number | null\n): string {\n  if (overrideHeight !== undefined && overrideHeight !== null) {\n    return `${overrideHeight}px`;\n  }\n  return comp.layout?.height || 'auto';\n}\n\n/**\n * Resolves the CSS min-height property for a runtime component.\n */\nexport function resolveComponentMinHeight(\n  comp: ReportComponentDefinition,\n  overrideHeight?: number | null\n): string {\n  if (overrideHeight !== undefined && overrideHeight !== null) {\n    return `${overrideHeight}px`;\n  }\n  return comp.layout?.minHeight || 'auto';\n}\n\n/**\n * Calculates new snapped span given drag deltaX, column width, and grid gap.\n */\nexport function calculateSnappedSpan(\n  deltaX: number,\n  startSpan: number,\n  colWidth: number,\n  gap: number,\n  totalCols: number\n): number {\n  const step = colWidth + gap;\n  if (step <= 0) return startSpan;\n  const spanDelta = Math.round(deltaX / step);\n  return Math.max(1, Math.min(totalCols, startSpan + spanDelta));\n}\n\n/**\n * Calculates new height given drag deltaY and minimum height constraint.\n */\nexport function calculateSnappedHeight(\n  deltaY: number,\n  startHeight: number,\n  minHeight: number = 50\n): number {\n  return Math.max(minHeight, Math.round(startHeight + deltaY));\n}\n\n/**\n * Maps component type to standard icon identifier.\n */\nexport function getComponentIconName(type: string): string {\n  switch (type) {\n    case 'input': return 'text-fields';\n    case 'dropdown': return 'dropdown';\n    case 'date': return 'calendar';\n    case 'number': return 'number';\n    case 'checkbox': return 'checkbox';\n    case 'button': return 'button';\n    case 'kpi-card': return 'kpi';\n    case 'chart': return 'chart-bar';\n    default: return 'box';\n  }\n}\n"]}

package/esm2022/lib/features/export/index.mjs

@@ -0,0 +1,2 @@
+export { ReportExportService, sanitizeCsvCell, generateCsvContent } from './services/report-export.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9mZWF0dXJlcy9leHBvcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLG1CQUFtQixFQUNuQixlQUFlLEVBQ2Ysa0JBQWtCLEVBQ25CLE1BQU0sa0NBQWtDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEV4cG9ydENvbHVtbiwgQ3N2RXhwb3J0T3B0aW9ucywgSnNvbkV4cG9ydE9wdGlvbnMgfSBmcm9tICcuL21vZGVscy9leHBvcnQubW9kZWxzJztcbmV4cG9ydCB7XG4gIFJlcG9ydEV4cG9ydFNlcnZpY2UsXG4gIHNhbml0aXplQ3N2Q2VsbCxcbiAgZ2VuZXJhdGVDc3ZDb250ZW50XG59IGZyb20gJy4vc2VydmljZXMvcmVwb3J0LWV4cG9ydC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/features/export/models/export.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0Lm1vZGVscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J3YXlzLXJlcG9ydC9zcmMvbGliL2ZlYXR1cmVzL2V4cG9ydC9tb2RlbHMvZXhwb3J0Lm1vZGVscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBFeHBvcnRDb2x1bW4ge1xuICBmaWVsZDogc3RyaW5nO1xuICBoZWFkZXI6IHN0cmluZztcbiAgZm9ybWF0dGVyPzogKHZhbHVlOiBhbnksIHJvdz86IFJlY29yZDxzdHJpbmcsIHVua25vd24+KSA9PiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3N2RXhwb3J0T3B0aW9ucyB7XG4gIGZpbGVOYW1lPzogc3RyaW5nO1xuICBjb2x1bW5zPzogRXhwb3J0Q29sdW1uW107XG4gIGluY2x1ZGVIZWFkZXI/OiBib29sZWFuO1xuICBkZWxpbWl0ZXI/OiBzdHJpbmc7XG4gIGFkZEJvbT86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSnNvbkV4cG9ydE9wdGlvbnMge1xuICBmaWxlTmFtZT86IHN0cmluZztcbiAgcHJldHR5PzogYm9vbGVhbjtcbn1cbiJdfQ==

package/esm2022/lib/features/export/services/report-export.service.mjs

@@ -0,0 +1,107 @@
+import { Injectable, inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Sanitizes and escapes a single cell value for CSV output.
+ */
+export function sanitizeCsvCell(value, delimiter = ',') {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    let str = String(value);
+    // If value contains delimiter, quote, or newline, escape and wrap in quotes
+    const mustQuote = str.includes(delimiter) ||
+        str.includes('"') ||
+        str.includes('\n') ||
+        str.includes('\r');
+    if (mustQuote) {
+        str = '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+/**
+ * Pure generator function to create CSV content string from row data and columns.
+ */
+export function generateCsvContent(rows, columns, delimiter = ',', includeHeader = true, addBom = true) {
+    const lines = [];
+    if (includeHeader) {
+        const headerLine = columns
+            .map((col) => sanitizeCsvCell(col.header, delimiter))
+            .join(delimiter);
+        lines.push(headerLine);
+    }
+    for (const row of rows) {
+        const rowValues = columns.map((col) => {
+            const val = row[col.field];
+            const formatted = col.formatter ? col.formatter(val, row) : val;
+            return sanitizeCsvCell(formatted, delimiter);
+        });
+        lines.push(rowValues.join(delimiter));
+    }
+    const csvBody = lines.join('\r\n');
+    return addBom ? '\uFEFF' + csvBody : csvBody;
+}
+export class ReportExportService {
+    document = inject(DOCUMENT);
+    /**
+     * Generates and triggers browser download of a CSV file.
+     */
+    exportCsv(rows, options = {}) {
+        if (!rows || rows.length === 0) {
+            console.warn('[bways-report] No rows to export');
+            return;
+        }
+        const delimiter = options.delimiter ?? ',';
+        const includeHeader = options.includeHeader !== false;
+        const addBom = options.addBom !== false;
+        const fileName = options.fileName || `report-export-${Date.now()}.csv`;
+        // If columns not provided, infer from first row keys
+        const columns = options.columns && options.columns.length > 0
+            ? options.columns
+            : Object.keys(rows[0]).map((key) => ({
+                field: key,
+                header: key
+            }));
+        const csvContent = generateCsvContent(rows, columns, delimiter, includeHeader, addBom);
+        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+        this.downloadBlob(blob, fileName);
+    }
+    /**
+     * Generates and triggers browser download of a JSON file.
+     */
+    exportJson(data, options = {}) {
+        const fileName = options.fileName || `report-export-${Date.now()}.json`;
+        const pretty = options.pretty !== false;
+        const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+        const blob = new Blob([jsonString], { type: 'application/json;charset=utf-8;' });
+        this.downloadBlob(blob, fileName);
+    }
+    /**
+     * Safe file download trigger via temporary anchor tag.
+     */
+    downloadBlob(blob, fileName) {
+        if (!this.document || !this.document.createElement) {
+            return;
+        }
+        const url = URL.createObjectURL(blob);
+        const link = this.document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        link.style.display = 'none';
+        this.document.body.appendChild(link);
+        link.click();
+        setTimeout(() => {
+            this.document.body.removeChild(link);
+            URL.revokeObjectURL(url);
+        }, 100);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportExportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-export.service.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/export/services/report-export.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { CsvExportOptions, ExportColumn, JsonExportOptions } from '../models/export.models';\n\n/**\n * Sanitizes and escapes a single cell value for CSV output.\n */\nexport function sanitizeCsvCell(value: unknown, delimiter: string = ','): string {\n  if (value === null || value === undefined) {\n    return '';\n  }\n\n  let str = String(value);\n\n  // If value contains delimiter, quote, or newline, escape and wrap in quotes\n  const mustQuote =\n    str.includes(delimiter) ||\n    str.includes('\"') ||\n    str.includes('\\n') ||\n    str.includes('\\r');\n\n  if (mustQuote) {\n    str = '\"' + str.replace(/\"/g, '\"\"') + '\"';\n  }\n\n  return str;\n}\n\n/**\n * Pure generator function to create CSV content string from row data and columns.\n */\nexport function generateCsvContent(\n  rows: Record<string, unknown>[],\n  columns: ExportColumn[],\n  delimiter: string = ',',\n  includeHeader: boolean = true,\n  addBom: boolean = true\n): string {\n  const lines: string[] = [];\n\n  if (includeHeader) {\n    const headerLine = columns\n      .map((col) => sanitizeCsvCell(col.header, delimiter))\n      .join(delimiter);\n    lines.push(headerLine);\n  }\n\n  for (const row of rows) {\n    const rowValues = columns.map((col) => {\n      const val = row[col.field];\n      const formatted = col.formatter ? col.formatter(val, row) : val;\n      return sanitizeCsvCell(formatted, delimiter);\n    });\n    lines.push(rowValues.join(delimiter));\n  }\n\n  const csvBody = lines.join('\\r\\n');\n  return addBom ? '\\uFEFF' + csvBody : csvBody;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ReportExportService {\n  private readonly document = inject(DOCUMENT);\n\n  /**\n   * Generates and triggers browser download of a CSV file.\n   */\n  exportCsv(rows: Record<string, unknown>[], options: CsvExportOptions = {}): void {\n    if (!rows || rows.length === 0) {\n      console.warn('[bways-report] No rows to export');\n      return;\n    }\n\n    const delimiter = options.delimiter ?? ',';\n    const includeHeader = options.includeHeader !== false;\n    const addBom = options.addBom !== false;\n    const fileName = options.fileName || `report-export-${Date.now()}.csv`;\n\n    // If columns not provided, infer from first row keys\n    const columns: ExportColumn[] =\n      options.columns && options.columns.length > 0\n        ? options.columns\n        : Object.keys(rows[0]).map((key) => ({\n            field: key,\n            header: key\n          }));\n\n    const csvContent = generateCsvContent(rows, columns, delimiter, includeHeader, addBom);\n    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\n    this.downloadBlob(blob, fileName);\n  }\n\n  /**\n   * Generates and triggers browser download of a JSON file.\n   */\n  exportJson(data: unknown, options: JsonExportOptions = {}): void {\n    const fileName = options.fileName || `report-export-${Date.now()}.json`;\n    const pretty = options.pretty !== false;\n    const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);\n\n    const blob = new Blob([jsonString], { type: 'application/json;charset=utf-8;' });\n    this.downloadBlob(blob, fileName);\n  }\n\n  /**\n   * Safe file download trigger via temporary anchor tag.\n   */\n  private downloadBlob(blob: Blob, fileName: string): void {\n    if (!this.document || !this.document.createElement) {\n      return;\n    }\n\n    const url = URL.createObjectURL(blob);\n    const link = this.document.createElement('a');\n    link.href = url;\n    link.download = fileName;\n    link.style.display = 'none';\n\n    this.document.body.appendChild(link);\n    link.click();\n\n    setTimeout(() => {\n      this.document.body.removeChild(link);\n      URL.revokeObjectURL(url);\n    }, 100);\n  }\n}\n"]}