bways-report 0.1.0

package/esm2022/lib/features/index.mjs

@@ -0,0 +1,6 @@
+export * from './runtime';
+export * from './designer';
+export * from './persistence';
+export * from './routing';
+export * from './export';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9mZWF0dXJlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcnVudGltZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rlc2lnbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vcGVyc2lzdGVuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0aW5nJztcbmV4cG9ydCAqIGZyb20gJy4vZXhwb3J0JztcbiJdfQ==

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

@@ -0,0 +1,2 @@
+export * from './services';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9mZWF0dXJlcy9wZXJzaXN0ZW5jZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMnO1xuIl19

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

@@ -0,0 +1,4 @@
+export { SchemaValidatorService, validateReportSchema, } from './schema-validator.service';
+export { ReportVersioningService } from './report-versioning.service';
+export { ReportStoreService } from './report-store.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9mZWF0dXJlcy9wZXJzaXN0ZW5jZS9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsc0JBQXNCLEVBQ3RCLG9CQUFvQixHQUNyQixNQUFNLDRCQUE0QixDQUFDO0FBR3BDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBR3RFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgU2NoZW1hVmFsaWRhdG9yU2VydmljZSxcbiAgdmFsaWRhdGVSZXBvcnRTY2hlbWEsXG59IGZyb20gJy4vc2NoZW1hLXZhbGlkYXRvci5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHsgU2NoZW1hVmFsaWRhdGlvblJlc3VsdCB9IGZyb20gJy4vc2NoZW1hLXZhbGlkYXRvci5zZXJ2aWNlJztcblxuZXhwb3J0IHsgUmVwb3J0VmVyc2lvbmluZ1NlcnZpY2UgfSBmcm9tICcuL3JlcG9ydC12ZXJzaW9uaW5nLnNlcnZpY2UnO1xuZXhwb3J0IHR5cGUgeyBSZXBvcnREaWZmU3VtbWFyeSB9IGZyb20gJy4vcmVwb3J0LXZlcnNpb25pbmcuc2VydmljZSc7XG5cbmV4cG9ydCB7IFJlcG9ydFN0b3JlU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXN0b3JlLnNlcnZpY2UnO1xuIl19

package/esm2022/lib/features/persistence/services/report-store.service.mjs

@@ -0,0 +1,183 @@
+import { computed, inject, Injectable, signal, } from '@angular/core';
+import { of, tap, throwError } from 'rxjs';
+import { ReportPersistenceAdapter } from '../../../data-access/contracts/report-persistence.contract';
+import { SchemaValidatorService } from './schema-validator.service';
+import * as i0 from "@angular/core";
+/**
+ * ReportStoreService manages application-wide cached report states,
+ * listing, and reactive access via Angular signals.
+ */
+export class ReportStoreService {
+    adapter = inject(ReportPersistenceAdapter, { optional: true });
+    validator = inject(SchemaValidatorService);
+    /** List of all known report summaries */
+    summaries = signal([]);
+    /** In-memory cache of loaded full report definitions by ID */
+    cache = signal(new Map());
+    /** Currently selected report ID */
+    activeReportId = signal(null);
+    /** Loading state indicator */
+    isLoading = signal(false);
+    /** Current error message */
+    error = signal(null);
+    /** Active report definition computed from cache */
+    activeReport = computed(() => {
+        const id = this.activeReportId();
+        if (!id)
+            return null;
+        return this.cache().get(id) ?? null;
+    });
+    /**
+     * Fetches the list of all available reports.
+     */
+    loadSummaries() {
+        if (!this.adapter) {
+            return of(this.summaries());
+        }
+        this.isLoading.set(true);
+        this.error.set(null);
+        return this.adapter.list().pipe(tap({
+            next: (list) => {
+                this.summaries.set(list);
+                this.isLoading.set(false);
+            },
+            error: (err) => {
+                this.error.set(err?.message ?? 'Failed to load report list.');
+                this.isLoading.set(false);
+            },
+        }));
+    }
+    /**
+     * Loads a report definition by ID, using cached instance if available.
+     *
+     * @param reportId - ID of the report to load.
+     * @param forceRefresh - If true, bypasses the in-memory cache.
+     */
+    loadReport(reportId, forceRefresh = false) {
+        if (!forceRefresh) {
+            const cached = this.cache().get(reportId);
+            if (cached) {
+                this.activeReportId.set(reportId);
+                return of(cached);
+            }
+        }
+        if (!this.adapter) {
+            return throwError(() => new Error('ReportPersistenceAdapter not configured.'));
+        }
+        this.isLoading.set(true);
+        this.error.set(null);
+        return this.adapter.load(reportId).pipe(tap({
+            next: (def) => {
+                this.validator.assertValid(def);
+                const nextCache = new Map(this.cache());
+                nextCache.set(reportId, def);
+                this.cache.set(nextCache);
+                this.activeReportId.set(reportId);
+                this.isLoading.set(false);
+            },
+            error: (err) => {
+                this.error.set(err?.message ?? `Failed to load report "${reportId}".`);
+                this.isLoading.set(false);
+            },
+        }));
+    }
+    /**
+     * Saves a report definition, validates it, and updates local cache.
+     */
+    saveReport(report) {
+        this.validator.assertValid(report);
+        if (!this.adapter) {
+            // In-memory update if no adapter configured
+            const nextCache = new Map(this.cache());
+            nextCache.set(report.id, report);
+            this.cache.set(nextCache);
+            this.updateSummaryInList(report);
+            return of(report);
+        }
+        this.isLoading.set(true);
+        this.error.set(null);
+        return this.adapter.save(report).pipe(tap({
+            next: (saved) => {
+                const nextCache = new Map(this.cache());
+                nextCache.set(saved.id, saved);
+                this.cache.set(nextCache);
+                this.updateSummaryInList(saved);
+                this.isLoading.set(false);
+            },
+            error: (err) => {
+                this.error.set(err?.message ?? `Failed to save report "${report.id}".`);
+                this.isLoading.set(false);
+            },
+        }));
+    }
+    /**
+     * Deletes a report definition by ID.
+     */
+    deleteReport(reportId) {
+        if (!this.adapter) {
+            const nextCache = new Map(this.cache());
+            nextCache.delete(reportId);
+            this.cache.set(nextCache);
+            this.summaries.set(this.summaries().filter((s) => s.id !== reportId));
+            if (this.activeReportId() === reportId) {
+                this.activeReportId.set(null);
+            }
+            return of(void 0);
+        }
+        this.isLoading.set(true);
+        return this.adapter.delete(reportId).pipe(tap({
+            next: () => {
+                const nextCache = new Map(this.cache());
+                nextCache.delete(reportId);
+                this.cache.set(nextCache);
+                this.summaries.set(this.summaries().filter((s) => s.id !== reportId));
+                if (this.activeReportId() === reportId) {
+                    this.activeReportId.set(null);
+                }
+                this.isLoading.set(false);
+            },
+            error: (err) => {
+                this.error.set(err?.message ?? `Failed to delete report "${reportId}".`);
+                this.isLoading.set(false);
+            },
+        }));
+    }
+    /**
+     * Sets the active report ID.
+     */
+    setActiveReport(id) {
+        this.activeReportId.set(id);
+    }
+    /**
+     * Clears the in-memory cache.
+     */
+    clearCache() {
+        this.cache.set(new Map());
+    }
+    updateSummaryInList(def) {
+        const list = [...this.summaries()];
+        const idx = list.findIndex((s) => s.id === def.id);
+        const summary = {
+            id: def.id,
+            name: def.name,
+            description: def.description,
+            version: def.version,
+            isPublished: !def.metadata?.['isDraft'],
+            lastModified: new Date().toISOString(),
+        };
+        if (idx >= 0) {
+            list[idx] = summary;
+        }
+        else {
+            list.push(summary);
+        }
+        this.summaries.set(list);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStoreService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStoreService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-store.service.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/persistence/services/report-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  computed,\n  inject,\n  Injectable,\n  signal,\n} from '@angular/core';\nimport { Observable, of, tap, throwError } from 'rxjs';\nimport {\n  ReportDefinition,\n  ReportSummary,\n} from '../../../core/models/report-definition.model';\nimport { ReportPersistenceAdapter } from '../../../data-access/contracts/report-persistence.contract';\nimport { SchemaValidatorService } from './schema-validator.service';\n\n/**\n * ReportStoreService manages application-wide cached report states,\n * listing, and reactive access via Angular signals.\n */\n@Injectable({ providedIn: 'root' })\nexport class ReportStoreService {\n  private readonly adapter = inject(ReportPersistenceAdapter, { optional: true });\n  private readonly validator = inject(SchemaValidatorService);\n\n  /** List of all known report summaries */\n  readonly summaries = signal<ReportSummary[]>([]);\n\n  /** In-memory cache of loaded full report definitions by ID */\n  private readonly cache = signal<Map<string, ReportDefinition>>(new Map());\n\n  /** Currently selected report ID */\n  readonly activeReportId = signal<string | null>(null);\n\n  /** Loading state indicator */\n  readonly isLoading = signal<boolean>(false);\n\n  /** Current error message */\n  readonly error = signal<string | null>(null);\n\n  /** Active report definition computed from cache */\n  readonly activeReport = computed<ReportDefinition | null>(() => {\n    const id = this.activeReportId();\n    if (!id) return null;\n    return this.cache().get(id) ?? null;\n  });\n\n  /**\n   * Fetches the list of all available reports.\n   */\n  loadSummaries(): Observable<ReportSummary[]> {\n    if (!this.adapter) {\n      return of(this.summaries());\n    }\n\n    this.isLoading.set(true);\n    this.error.set(null);\n\n    return this.adapter.list().pipe(\n      tap({\n        next: (list) => {\n          this.summaries.set(list);\n          this.isLoading.set(false);\n        },\n        error: (err) => {\n          this.error.set(err?.message ?? 'Failed to load report list.');\n          this.isLoading.set(false);\n        },\n      })\n    );\n  }\n\n  /**\n   * Loads a report definition by ID, using cached instance if available.\n   *\n   * @param reportId - ID of the report to load.\n   * @param forceRefresh - If true, bypasses the in-memory cache.\n   */\n  loadReport(reportId: string, forceRefresh = false): Observable<ReportDefinition> {\n    if (!forceRefresh) {\n      const cached = this.cache().get(reportId);\n      if (cached) {\n        this.activeReportId.set(reportId);\n        return of(cached);\n      }\n    }\n\n    if (!this.adapter) {\n      return throwError(() => new Error('ReportPersistenceAdapter not configured.'));\n    }\n\n    this.isLoading.set(true);\n    this.error.set(null);\n\n    return this.adapter.load(reportId).pipe(\n      tap({\n        next: (def) => {\n          this.validator.assertValid(def);\n          const nextCache = new Map(this.cache());\n          nextCache.set(reportId, def);\n          this.cache.set(nextCache);\n          this.activeReportId.set(reportId);\n          this.isLoading.set(false);\n        },\n        error: (err) => {\n          this.error.set(err?.message ?? `Failed to load report \"${reportId}\".`);\n          this.isLoading.set(false);\n        },\n      })\n    );\n  }\n\n  /**\n   * Saves a report definition, validates it, and updates local cache.\n   */\n  saveReport(report: ReportDefinition): Observable<ReportDefinition> {\n    this.validator.assertValid(report);\n\n    if (!this.adapter) {\n      // In-memory update if no adapter configured\n      const nextCache = new Map(this.cache());\n      nextCache.set(report.id, report);\n      this.cache.set(nextCache);\n      this.updateSummaryInList(report);\n      return of(report);\n    }\n\n    this.isLoading.set(true);\n    this.error.set(null);\n\n    return this.adapter.save(report).pipe(\n      tap({\n        next: (saved) => {\n          const nextCache = new Map(this.cache());\n          nextCache.set(saved.id, saved);\n          this.cache.set(nextCache);\n          this.updateSummaryInList(saved);\n          this.isLoading.set(false);\n        },\n        error: (err) => {\n          this.error.set(err?.message ?? `Failed to save report \"${report.id}\".`);\n          this.isLoading.set(false);\n        },\n      })\n    );\n  }\n\n  /**\n   * Deletes a report definition by ID.\n   */\n  deleteReport(reportId: string): Observable<void> {\n    if (!this.adapter) {\n      const nextCache = new Map(this.cache());\n      nextCache.delete(reportId);\n      this.cache.set(nextCache);\n      this.summaries.set(this.summaries().filter((s) => s.id !== reportId));\n      if (this.activeReportId() === reportId) {\n        this.activeReportId.set(null);\n      }\n      return of(void 0);\n    }\n\n    this.isLoading.set(true);\n    return this.adapter.delete(reportId).pipe(\n      tap({\n        next: () => {\n          const nextCache = new Map(this.cache());\n          nextCache.delete(reportId);\n          this.cache.set(nextCache);\n          this.summaries.set(this.summaries().filter((s) => s.id !== reportId));\n          if (this.activeReportId() === reportId) {\n            this.activeReportId.set(null);\n          }\n          this.isLoading.set(false);\n        },\n        error: (err) => {\n          this.error.set(err?.message ?? `Failed to delete report \"${reportId}\".`);\n          this.isLoading.set(false);\n        },\n      })\n    );\n  }\n\n  /**\n   * Sets the active report ID.\n   */\n  setActiveReport(id: string | null): void {\n    this.activeReportId.set(id);\n  }\n\n  /**\n   * Clears the in-memory cache.\n   */\n  clearCache(): void {\n    this.cache.set(new Map());\n  }\n\n  private updateSummaryInList(def: ReportDefinition): void {\n    const list = [...this.summaries()];\n    const idx = list.findIndex((s) => s.id === def.id);\n    const summary: ReportSummary = {\n      id: def.id,\n      name: def.name,\n      description: def.description,\n      version: def.version,\n      isPublished: !def.metadata?.['isDraft'],\n      lastModified: new Date().toISOString(),\n    };\n\n    if (idx >= 0) {\n      list[idx] = summary;\n    } else {\n      list.push(summary);\n    }\n    this.summaries.set(list);\n  }\n}\n"]}

package/esm2022/lib/features/persistence/services/report-versioning.service.mjs

@@ -0,0 +1,81 @@
+import { inject, Injectable } from '@angular/core';
+import { SchemaValidatorService } from './schema-validator.service';
+import * as i0 from "@angular/core";
+/**
+ * ReportVersioningService manages the draft and publishing lifecycle of report definitions.
+ */
+export class ReportVersioningService {
+    validator = inject(SchemaValidatorService);
+    /**
+     * Prepares a new draft version from an existing definition.
+     */
+    createDraft(report) {
+        return {
+            ...JSON.parse(JSON.stringify(report)),
+            metadata: {
+                ...(report.metadata ?? {}),
+                isDraft: true,
+                draftCreatedAt: new Date().toISOString(),
+            },
+        };
+    }
+    /**
+     * Publishes a draft report definition, validating its integrity and incrementing its version.
+     */
+    publish(report) {
+        this.validator.assertValid(report);
+        const nextVersion = (report.version ?? 1) + 1;
+        const publishedMeta = {
+            ...(report.metadata ?? {}),
+            isDraft: false,
+            publishedAt: new Date().toISOString(),
+        };
+        return {
+            ...JSON.parse(JSON.stringify(report)),
+            version: nextVersion,
+            metadata: publishedMeta,
+        };
+    }
+    /**
+     * Compares two versions of a report definition to produce a structured diff summary.
+     */
+    compareVersions(v1, v2) {
+        const v1CompMap = new Map(v1.components.map((c) => [c.id, c]));
+        const v2CompMap = new Map(v2.components.map((c) => [c.id, c]));
+        const addedComponentIds = [];
+        const removedComponentIds = [];
+        const modifiedComponentIds = [];
+        for (const [id, comp] of v2CompMap) {
+            if (!v1CompMap.has(id)) {
+                addedComponentIds.push(id);
+            }
+            else {
+                const original = v1CompMap.get(id);
+                if (JSON.stringify(original) !== JSON.stringify(comp)) {
+                    modifiedComponentIds.push(id);
+                }
+            }
+        }
+        for (const id of v1CompMap.keys()) {
+            if (!v2CompMap.has(id)) {
+                removedComponentIds.push(id);
+            }
+        }
+        const hasLayoutChanges = JSON.stringify(v1.layout) !== JSON.stringify(v2.layout);
+        const hasGridChanges = JSON.stringify(v1.grid) !== JSON.stringify(v2.grid);
+        return {
+            hasLayoutChanges,
+            hasGridChanges,
+            addedComponentIds,
+            removedComponentIds,
+            modifiedComponentIds,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportVersioningService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportVersioningService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportVersioningService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/features/persistence/services/schema-validator.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import { ReportDefinitionError } from '../../../core/errors/reporting-errors';
+import * as i0 from "@angular/core";
+/**
+ * Pure function that validates the integrity and constraints of a ReportDefinition.
+ *
+ * Checks:
+ * - ID and Name presence
+ * - Unique component IDs
+ * - Unique parameter/input keys
+ * - Grid data source references
+ * - Column span boundary violations
+ */
+export function validateReportSchema(definition) {
+    const errors = [];
+    const warnings = [];
+    if (!definition) {
+        return { valid: false, errors: ['Report definition is null or undefined.'], warnings: [] };
+    }
+    if (!definition.id || !definition.id.trim()) {
+        errors.push('Report definition missing required "id".');
+    }
+    if (!definition.name || !definition.name.trim()) {
+        errors.push('Report definition missing required "name".');
+    }
+    const columns = definition.layout?.columns ?? 12;
+    if (columns < 1 || columns > 36) {
+        errors.push(`Invalid layout columns count: ${columns}. Must be between 1 and 36.`);
+    }
+    // Verify component IDs and keys
+    const componentIds = new Set();
+    const componentKeys = new Set();
+    for (const comp of definition.components ?? []) {
+        if (!comp.id) {
+            errors.push('Encountered component missing unique "id".');
+        }
+        else if (componentIds.has(comp.id)) {
+            errors.push(`Duplicate component ID found: "${comp.id}".`);
+        }
+        else {
+            componentIds.add(comp.id);
+        }
+        if (comp.key) {
+            if (componentKeys.has(comp.key)) {
+                errors.push(`Duplicate form field key found: "${comp.key}".`);
+            }
+            else {
+                componentKeys.add(comp.key);
+            }
+        }
+        else if (comp.type !== 'button' && comp.type !== 'display') {
+            warnings.push(`Input component "${comp.id}" (${comp.type}) has no "key" defined for form binding.`);
+        }
+        if (comp.layout?.columnSpan && comp.layout.columnSpan > columns) {
+            warnings.push(`Component "${comp.id}" columnSpan (${comp.layout.columnSpan}) exceeds page total columns (${columns}).`);
+        }
+    }
+    // Verify grid & data source integrity
+    if (definition.grid) {
+        const dsId = definition.grid.dataSourceId;
+        const dsExists = (definition.dataSources ?? []).some((ds) => ds.id === dsId);
+        if (!dsExists) {
+            errors.push(`Grid references dataSourceId "${dsId}", but no matching data source was found.`);
+        }
+        if (!definition.grid.columns || definition.grid.columns.length === 0) {
+            warnings.push('Grid definition has no columns configured.');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * SchemaValidatorService provides schema verification methods.
+ */
+export class SchemaValidatorService {
+    /**
+     * Validates a report definition and returns errors/warnings without throwing.
+     */
+    validate(definition) {
+        return validateReportSchema(definition);
+    }
+    /**
+     * Asserts that a report definition is valid.
+     * Throws `ReportDefinitionError` if any validation error is detected.
+     */
+    assertValid(definition) {
+        const result = this.validate(definition);
+        if (!result.valid) {
+            throw new ReportDefinitionError(result.errors.join('; '), definition?.id);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SchemaValidatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SchemaValidatorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SchemaValidatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-validator.service.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/persistence/services/schema-validator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ReportDefinition } from '../../../core/models/report-definition.model';\nimport { ReportDefinitionError } from '../../../core/errors/reporting-errors';\n\nexport interface SchemaValidationResult {\n  valid: boolean;\n  errors: string[];\n  warnings: string[];\n}\n\n/**\n * Pure function that validates the integrity and constraints of a ReportDefinition.\n *\n * Checks:\n * - ID and Name presence\n * - Unique component IDs\n * - Unique parameter/input keys\n * - Grid data source references\n * - Column span boundary violations\n */\nexport function validateReportSchema(definition: ReportDefinition): SchemaValidationResult {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  if (!definition) {\n    return { valid: false, errors: ['Report definition is null or undefined.'], warnings: [] };\n  }\n\n  if (!definition.id || !definition.id.trim()) {\n    errors.push('Report definition missing required \"id\".');\n  }\n\n  if (!definition.name || !definition.name.trim()) {\n    errors.push('Report definition missing required \"name\".');\n  }\n\n  const columns = definition.layout?.columns ?? 12;\n  if (columns < 1 || columns > 36) {\n    errors.push(`Invalid layout columns count: ${columns}. Must be between 1 and 36.`);\n  }\n\n  // Verify component IDs and keys\n  const componentIds = new Set<string>();\n  const componentKeys = new Set<string>();\n\n  for (const comp of definition.components ?? []) {\n    if (!comp.id) {\n      errors.push('Encountered component missing unique \"id\".');\n    } else if (componentIds.has(comp.id)) {\n      errors.push(`Duplicate component ID found: \"${comp.id}\".`);\n    } else {\n      componentIds.add(comp.id);\n    }\n\n    if (comp.key) {\n      if (componentKeys.has(comp.key)) {\n        errors.push(`Duplicate form field key found: \"${comp.key}\".`);\n      } else {\n        componentKeys.add(comp.key);\n      }\n    } else if (comp.type !== 'button' && comp.type !== 'display') {\n      warnings.push(`Input component \"${comp.id}\" (${comp.type}) has no \"key\" defined for form binding.`);\n    }\n\n    if (comp.layout?.columnSpan && comp.layout.columnSpan > columns) {\n      warnings.push(\n        `Component \"${comp.id}\" columnSpan (${comp.layout.columnSpan}) exceeds page total columns (${columns}).`\n      );\n    }\n  }\n\n  // Verify grid & data source integrity\n  if (definition.grid) {\n    const dsId = definition.grid.dataSourceId;\n    const dsExists = (definition.dataSources ?? []).some((ds) => ds.id === dsId);\n\n    if (!dsExists) {\n      errors.push(`Grid references dataSourceId \"${dsId}\", but no matching data source was found.`);\n    }\n\n    if (!definition.grid.columns || definition.grid.columns.length === 0) {\n      warnings.push('Grid definition has no columns configured.');\n    }\n  }\n\n  return {\n    valid: errors.length === 0,\n    errors,\n    warnings,\n  };\n}\n\n/**\n * SchemaValidatorService provides schema verification methods.\n */\n@Injectable({ providedIn: 'root' })\nexport class SchemaValidatorService {\n  /**\n   * Validates a report definition and returns errors/warnings without throwing.\n   */\n  validate(definition: ReportDefinition): SchemaValidationResult {\n    return validateReportSchema(definition);\n  }\n\n  /**\n   * Asserts that a report definition is valid.\n   * Throws `ReportDefinitionError` if any validation error is detected.\n   */\n  assertValid(definition: ReportDefinition): void {\n    const result = this.validate(definition);\n    if (!result.valid) {\n      throw new ReportDefinitionError(result.errors.join('; '), definition?.id);\n    }\n  }\n}\n"]}

package/esm2022/lib/features/routing/components/routed-report-designer.component.mjs

@@ -0,0 +1,156 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, inject, signal } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ActivatedRoute, Router } from '@angular/router';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ReportStoreService } from '../../persistence/services/report-store.service';
+import { DesignerComponent } from '../../designer/designer.component';
+import { RptIconComponent } from '../../../primitives/components/icon/rpt-icon.component';
+import * as i0 from "@angular/core";
+export class RoutedReportDesignerComponent {
+    route = inject(ActivatedRoute);
+    router = inject(Router);
+    store = inject(ReportStoreService);
+    destroyRef = inject(DestroyRef);
+    report = signal(null);
+    loading = signal(true);
+    savedFeedback = signal(false);
+    ngOnInit() {
+        const reportId = this.route.snapshot.paramMap.get('reportId');
+        if (!reportId || reportId === 'new') {
+            // Create blank report
+            this.report.set(this.createBlankReport());
+            this.loading.set(false);
+            return;
+        }
+        this.store.loadReport(reportId)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: (rep) => {
+                this.report.set(rep ?? this.createBlankReport());
+                this.loading.set(false);
+            },
+            error: () => {
+                this.report.set(this.createBlankReport());
+                this.loading.set(false);
+            }
+        });
+    }
+    onSaveReport(updatedReport) {
+        this.store.saveReport(updatedReport)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: () => {
+                this.savedFeedback.set(true);
+                setTimeout(() => this.savedFeedback.set(false), 2500);
+            },
+            error: (err) => {
+                console.error('[bways-report] Save report failed:', err);
+            }
+        });
+    }
+    goBack() {
+        const reportId = this.route.snapshot.paramMap.get('reportId');
+        if (reportId && reportId !== 'new') {
+            this.router.navigate(['../'], { relativeTo: this.route });
+        }
+        else {
+            this.router.navigate(['../'], { relativeTo: this.route });
+        }
+    }
+    createBlankReport() {
+        return {
+            id: `report-${Date.now()}`,
+            name: 'Untitled Report',
+            description: 'Newly created report',
+            category: 'General',
+            schemaVersion: 1,
+            version: 1,
+            components: [],
+            parameters: [],
+            dataSources: [
+                {
+                    id: 'ds-default',
+                    name: 'Default Data Source',
+                    endpoint: '/api/reports/data'
+                }
+            ],
+            grid: {
+                dataSourceId: 'ds-default',
+                columns: []
+            },
+            layout: {
+                columns: 12,
+                gap: 16
+            }
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RoutedReportDesignerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: RoutedReportDesignerComponent, isStandalone: true, selector: "rpt-routed-designer", ngImport: i0, template: `
+    <div class="rpt-routed-designer-host">
+      @if (loading()) {
+        <div class="rpt-routed-loading">
+          <div class="rpt-spinner"></div>
+          <p>Loading report designer...</p>
+        </div>
+      } @else {
+        <div class="rpt-routed-designer-bar">
+          <button
+            type="button"
+            class="rpt-btn rpt-btn-ghost rpt-btn-sm"
+            (click)="goBack()"
+            title="Return to report view"
+          >
+            <rpt-icon name="arrow-left" [size]="14" />
+            <span>Exit Designer</span>
+          </button>
+          @if (savedFeedback()) {
+            <span class="rpt-saved-pill">
+              <rpt-icon name="check" [size]="14" />
+              <span>Saved successfully</span>
+            </span>
+          }
+        </div>
+        <rpt-designer
+          [initialReport]="report()"
+          (save)="onSaveReport($event)"
+        />
+      }
+    </div>
+  `, isInline: true, styles: [".rpt-routed-designer-host{display:flex;flex-direction:column;height:100%;min-height:calc(100vh - 80px);box-sizing:border-box}.rpt-routed-designer-bar{display:flex;align-items:center;justify-content:space-between;padding:6px 16px;background:var(--rpt-surface-bg, #ffffff);border-bottom:1px solid var(--rpt-border-color, #e2e8f0)}.rpt-saved-pill{display:inline-flex;align-items:center;gap:5px;font-size:.8125rem;color:#166534;background:#dcfce7;padding:3px 10px;border-radius:9999px;font-weight:500;animation:rptFadeInOut 2.5s ease-in-out forwards}@keyframes rptFadeInOut{0%{opacity:0;transform:translateY(-4px)}15%{opacity:1;transform:translateY(0)}85%{opacity:1;transform:translateY(0)}to{opacity:0;transform:translateY(-4px)}}.rpt-routed-loading{display:flex;flex-direction:column;align-items:center;justify-content:center;height:300px;color:var(--rpt-text-muted, #64748b)}.rpt-spinner{width:36px;height:36px;border:3px solid var(--rpt-border-color, #e2e8f0);border-top-color:var(--rpt-primary, #2563eb);border-radius:50%;animation:rpt-spin .8s linear infinite;margin-bottom:12px}@keyframes rpt-spin{to{transform:rotate(360deg)}}.rpt-btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;padding:6px 12px;font-size:.8125rem;font-weight:500;border-radius:var(--rpt-radius-md, 6px);cursor:pointer;border:1px solid transparent;background:transparent;color:var(--rpt-text-muted, #64748b);transition:all .15s ease}.rpt-btn:hover{color:var(--rpt-text-color, #1e293b);background:var(--rpt-bg-subtle, #f1f5f9)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: DesignerComponent, selector: "rpt-designer", inputs: ["reportId", "initialReport"], outputs: ["save", "definitionChange"] }, { kind: "component", type: RptIconComponent, selector: "rpt-icon", inputs: ["name", "size", "color", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RoutedReportDesignerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'rpt-routed-designer', standalone: true, imports: [CommonModule, DesignerComponent, RptIconComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div class="rpt-routed-designer-host">
+      @if (loading()) {
+        <div class="rpt-routed-loading">
+          <div class="rpt-spinner"></div>
+          <p>Loading report designer...</p>
+        </div>
+      } @else {
+        <div class="rpt-routed-designer-bar">
+          <button
+            type="button"
+            class="rpt-btn rpt-btn-ghost rpt-btn-sm"
+            (click)="goBack()"
+            title="Return to report view"
+          >
+            <rpt-icon name="arrow-left" [size]="14" />
+            <span>Exit Designer</span>
+          </button>
+          @if (savedFeedback()) {
+            <span class="rpt-saved-pill">
+              <rpt-icon name="check" [size]="14" />
+              <span>Saved successfully</span>
+            </span>
+          }
+        </div>
+        <rpt-designer
+          [initialReport]="report()"
+          (save)="onSaveReport($event)"
+        />
+      }
+    </div>
+  `, styles: [".rpt-routed-designer-host{display:flex;flex-direction:column;height:100%;min-height:calc(100vh - 80px);box-sizing:border-box}.rpt-routed-designer-bar{display:flex;align-items:center;justify-content:space-between;padding:6px 16px;background:var(--rpt-surface-bg, #ffffff);border-bottom:1px solid var(--rpt-border-color, #e2e8f0)}.rpt-saved-pill{display:inline-flex;align-items:center;gap:5px;font-size:.8125rem;color:#166534;background:#dcfce7;padding:3px 10px;border-radius:9999px;font-weight:500;animation:rptFadeInOut 2.5s ease-in-out forwards}@keyframes rptFadeInOut{0%{opacity:0;transform:translateY(-4px)}15%{opacity:1;transform:translateY(0)}85%{opacity:1;transform:translateY(0)}to{opacity:0;transform:translateY(-4px)}}.rpt-routed-loading{display:flex;flex-direction:column;align-items:center;justify-content:center;height:300px;color:var(--rpt-text-muted, #64748b)}.rpt-spinner{width:36px;height:36px;border:3px solid var(--rpt-border-color, #e2e8f0);border-top-color:var(--rpt-primary, #2563eb);border-radius:50%;animation:rpt-spin .8s linear infinite;margin-bottom:12px}@keyframes rpt-spin{to{transform:rotate(360deg)}}.rpt-btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;padding:6px 12px;font-size:.8125rem;font-weight:500;border-radius:var(--rpt-radius-md, 6px);cursor:pointer;border:1px solid transparent;background:transparent;color:var(--rpt-text-muted, #64748b);transition:all .15s ease}.rpt-btn:hover{color:var(--rpt-text-color, #1e293b);background:var(--rpt-bg-subtle, #f1f5f9)}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routed-report-designer.component.js","sourceRoot":"","sources":["../../../../../../../projects/bways-report/src/lib/features/routing/components/routed-report-designer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  DestroyRef,\n  OnInit,\n  inject,\n  signal\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ReportDefinition } from '../../../core/models';\nimport { ReportStoreService } from '../../persistence/services/report-store.service';\nimport { DesignerComponent } from '../../designer/designer.component';\nimport { RptIconComponent } from '../../../primitives/components/icon/rpt-icon.component';\n\n\n@Component({\n  selector: 'rpt-routed-designer',\n  standalone: true,\n  imports: [CommonModule, DesignerComponent, RptIconComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div class=\"rpt-routed-designer-host\">\n      @if (loading()) {\n        <div class=\"rpt-routed-loading\">\n          <div class=\"rpt-spinner\"></div>\n          <p>Loading report designer...</p>\n        </div>\n      } @else {\n        <div class=\"rpt-routed-designer-bar\">\n          <button\n            type=\"button\"\n            class=\"rpt-btn rpt-btn-ghost rpt-btn-sm\"\n            (click)=\"goBack()\"\n            title=\"Return to report view\"\n          >\n            <rpt-icon name=\"arrow-left\" [size]=\"14\" />\n            <span>Exit Designer</span>\n          </button>\n          @if (savedFeedback()) {\n            <span class=\"rpt-saved-pill\">\n              <rpt-icon name=\"check\" [size]=\"14\" />\n              <span>Saved successfully</span>\n            </span>\n          }\n        </div>\n        <rpt-designer\n          [initialReport]=\"report()\"\n          (save)=\"onSaveReport($event)\"\n        />\n      }\n    </div>\n  `,\n  styles: [`\n    .rpt-routed-designer-host {\n      display: flex;\n      flex-direction: column;\n      height: 100%;\n      min-height: calc(100vh - 80px);\n      box-sizing: border-box;\n    }\n\n    .rpt-routed-designer-bar {\n      display: flex;\n      align-items: center;\n      justify-content: space-between;\n      padding: 6px 16px;\n      background: var(--rpt-surface-bg, #ffffff);\n      border-bottom: 1px solid var(--rpt-border-color, #e2e8f0);\n    }\n\n    .rpt-saved-pill {\n      display: inline-flex;\n      align-items: center;\n      gap: 5px;\n      font-size: 0.8125rem;\n      color: #166534;\n      background: #dcfce7;\n      padding: 3px 10px;\n      border-radius: 9999px;\n      font-weight: 500;\n      animation: rptFadeInOut 2.5s ease-in-out forwards;\n    }\n\n    @keyframes rptFadeInOut {\n      0% { opacity: 0; transform: translateY(-4px); }\n      15% { opacity: 1; transform: translateY(0); }\n      85% { opacity: 1; transform: translateY(0); }\n      100% { opacity: 0; transform: translateY(-4px); }\n    }\n\n    .rpt-routed-loading {\n      display: flex;\n      flex-direction: column;\n      align-items: center;\n      justify-content: center;\n      height: 300px;\n      color: var(--rpt-text-muted, #64748b);\n    }\n\n    .rpt-spinner {\n      width: 36px;\n      height: 36px;\n      border: 3px solid var(--rpt-border-color, #e2e8f0);\n      border-top-color: var(--rpt-primary, #2563eb);\n      border-radius: 50%;\n      animation: rpt-spin 0.8s linear infinite;\n      margin-bottom: 12px;\n    }\n\n    @keyframes rpt-spin {\n      to { transform: rotate(360deg); }\n    }\n\n    .rpt-btn {\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      gap: 6px;\n      padding: 6px 12px;\n      font-size: 0.8125rem;\n      font-weight: 500;\n      border-radius: var(--rpt-radius-md, 6px);\n      cursor: pointer;\n      border: 1px solid transparent;\n      background: transparent;\n      color: var(--rpt-text-muted, #64748b);\n      transition: all 0.15s ease;\n    }\n\n    .rpt-btn:hover {\n      color: var(--rpt-text-color, #1e293b);\n      background: var(--rpt-bg-subtle, #f1f5f9);\n    }\n  `]\n})\nexport class RoutedReportDesignerComponent implements OnInit {\n  private readonly route = inject(ActivatedRoute);\n  private readonly router = inject(Router);\n  private readonly store = inject(ReportStoreService);\n  private readonly destroyRef = inject(DestroyRef);\n\n  readonly report = signal<ReportDefinition | null>(null);\n  readonly loading = signal<boolean>(true);\n  readonly savedFeedback = signal<boolean>(false);\n\n  ngOnInit(): void {\n    const reportId = this.route.snapshot.paramMap.get('reportId');\n\n    if (!reportId || reportId === 'new') {\n      // Create blank report\n      this.report.set(this.createBlankReport());\n      this.loading.set(false);\n      return;\n    }\n\n    this.store.loadReport(reportId)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe({\n        next: (rep) => {\n          this.report.set(rep ?? this.createBlankReport());\n          this.loading.set(false);\n        },\n        error: () => {\n          this.report.set(this.createBlankReport());\n          this.loading.set(false);\n        }\n      });\n  }\n\n  onSaveReport(updatedReport: ReportDefinition): void {\n    this.store.saveReport(updatedReport)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe({\n        next: () => {\n          this.savedFeedback.set(true);\n          setTimeout(() => this.savedFeedback.set(false), 2500);\n        },\n        error: (err) => {\n          console.error('[bways-report] Save report failed:', err);\n        }\n      });\n  }\n\n  goBack(): void {\n    const reportId = this.route.snapshot.paramMap.get('reportId');\n    if (reportId && reportId !== 'new') {\n      this.router.navigate(['../'], { relativeTo: this.route });\n    } else {\n      this.router.navigate(['../'], { relativeTo: this.route });\n    }\n  }\n\n  private createBlankReport(): ReportDefinition {\n    return {\n      id: `report-${Date.now()}`,\n      name: 'Untitled Report',\n      description: 'Newly created report',\n      category: 'General',\n      schemaVersion: 1,\n      version: 1,\n      components: [],\n      parameters: [],\n      dataSources: [\n        {\n          id: 'ds-default',\n          name: 'Default Data Source',\n          endpoint: '/api/reports/data'\n        }\n      ],\n      grid: {\n        dataSourceId: 'ds-default',\n        columns: []\n      },\n      layout: {\n        columns: 12,\n        gap: 16\n      }\n    };\n  }\n}\n\n\n"]}