ngx-form-designer 0.0.23

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="ngx-form-designer" />
+export * from './public-api';

package/lib/data/data-catalog.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Defines a global data source available in the application.
+ */
+export interface DataSourceDefinition {
+    id: string;
+    label: string;
+    type: 'csv' | 'excel' | 'json' | 'api';
+    version?: string;
+    description?: string;
+    tags?: string[];
+    schema?: Record<string, 'string' | 'number' | 'boolean' | 'date' | 'any'>;
+    url?: string;
+    fileId?: string;
+    resultPath?: string;
+    labelKey?: string;
+    valueKey?: string;
+    eventId?: string;
+    eventAccess?: boolean;
+}
+/**
+ * Abstract contract for a global data catalog.
+ * Implementation will live in the host app or a future adapter.
+ */
+export declare abstract class DataCatalog {
+    /**
+     * Return all registered data sources available to the designer/runtime.
+     */
+    abstract listSources(): DataSourceDefinition[];
+    /**
+     * Look up a single data source by its ID.
+     */
+    abstract getSourceById(id: string): DataSourceDefinition | undefined;
+    /**
+     * Return all rows for a given source ID.
+     * Implementation can fetch from memory, storage, or a backend in the host app.
+     */
+    abstract getRows(id: string): any[];
+    /**
+     * Optional: Add or update a data source.
+     */
+    abstract upsert?(def: DataSourceDefinition, rows: any[]): void;
+    /**
+     * Optional: Remove a data source.
+     */
+    abstract remove?(id: string): void;
+}

package/lib/data/data-provider.d.ts

@@ -0,0 +1,69 @@
+import { InjectionToken } from '@angular/core';
+import { FieldSchema, DataSourceConfig, OptionSchema } from '../form-core/models';
+import { FormEngine } from '../form-core/form-engine';
+import * as i0 from "@angular/core";
+/**
+ * Central abstraction for resolving data for widgets.
+ * Implementations can be overridden by host apps if needed.
+ */
+export interface OptionsQuery {
+    term?: string;
+    limit?: number;
+    columns?: string[];
+}
+type DataRow = Record<string, unknown>;
+export declare abstract class DataProvider {
+    abstract getOptions(field: FieldSchema, engine?: FormEngine): Promise<OptionSchema[]>;
+    abstract getList(field: FieldSchema, engine?: FormEngine): Promise<DataRow[]>;
+    abstract getValue(field: FieldSchema, engine?: FormEngine): Promise<unknown>;
+    abstract resolveValue(field: FieldSchema, value: unknown): Promise<string>;
+    queryOptions(field: FieldSchema, query: {
+        term: string;
+        limit?: number;
+    }, engine?: FormEngine): Promise<OptionSchema[]>;
+    queryList(field: FieldSchema, query: ListQuery, engine?: FormEngine): Promise<ListResult>;
+}
+export interface ListQuery {
+    term?: string;
+    limit?: number;
+    offset?: number;
+    sort?: {
+        column: string;
+        dir: 'asc' | 'desc';
+    }[];
+}
+export interface ListResult {
+    rows: DataRow[];
+    total: number;
+}
+/**
+ * Helper to safely get the effective DataSourceConfig for a field.
+ */
+export declare function getEffectiveDataConfig(field: FieldSchema): DataSourceConfig;
+export declare const DATA_PROVIDER: InjectionToken<DataProvider>;
+export declare class DefaultDataProvider extends DataProvider {
+    private client;
+    private runtimeFieldDataAccessRegistry;
+    getOptions(field: FieldSchema, engine?: FormEngine): Promise<OptionSchema[]>;
+    queryOptions(field: FieldSchema, query: OptionsQuery, engine?: FormEngine): Promise<OptionSchema[]>;
+    getList(field: FieldSchema, engine?: FormEngine): Promise<DataRow[]>;
+    queryList(field: FieldSchema, query: ListQuery, engine?: FormEngine): Promise<ListResult>;
+    getValue(field: FieldSchema, engine?: FormEngine): Promise<unknown>;
+    resolveValue(field: FieldSchema, value: unknown): Promise<string>;
+    private getRawRows;
+    private getGlobalRows;
+    private resolveCollectionRows;
+    private extractRows;
+    private selectScalarRow;
+    private applyRowFilters;
+    private resolveFilters;
+    private resolveFilterValue;
+    private toOptionValue;
+    private toRowRecord;
+    private mapRowToOption;
+    private getRuntimeOptions;
+    private shouldUseLocalResolution;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDataProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultDataProvider>;
+}
+export {};

package/lib/data/data-source-client.d.ts

@@ -0,0 +1,59 @@
+import { InjectionToken } from '@angular/core';
+import { DataSourceDefinition } from './data-catalog';
+import * as i0 from "@angular/core";
+export interface DataSourceColumn {
+    name: string;
+    type?: string;
+}
+export interface DataSourceQueryFilter {
+    column: string;
+    op: 'eq' | 'neq' | 'in' | 'contains' | 'startsWith' | 'endsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'like';
+    value: any;
+}
+export interface DataSourceQuery {
+    select?: string[];
+    filters?: DataSourceQueryFilter[];
+    search?: {
+        term: string;
+        columns?: string[];
+    };
+    sort?: {
+        column: string;
+        dir: 'asc' | 'desc';
+    }[];
+    page?: {
+        limit?: number;
+        offset?: number;
+    };
+}
+export interface DataSourceQueryResult {
+    rows: any[];
+    total: number;
+}
+export type UploadSourceType = 'json' | 'csv';
+export interface CreateSourceRequest {
+    id?: string;
+    label?: string;
+    type: UploadSourceType;
+    rawData: string;
+}
+export interface DataSourceClient {
+    listSources(): Promise<DataSourceDefinition[]>;
+    getSourceById(id: string): Promise<DataSourceDefinition | undefined>;
+    getColumns(id: string): Promise<DataSourceColumn[]>;
+    query(id: string, q?: DataSourceQuery): Promise<DataSourceQueryResult>;
+    createSource?(req: CreateSourceRequest): Promise<DataSourceDefinition>;
+    deleteSource?(sourceId: string): Promise<void>;
+}
+export declare const DATA_SOURCE_CLIENT: InjectionToken<DataSourceClient>;
+export declare class DefaultDataSourceClient implements DataSourceClient {
+    private catalog;
+    listSources(): Promise<DataSourceDefinition[]>;
+    getSourceById(id: string): Promise<DataSourceDefinition | undefined>;
+    getColumns(id: string): Promise<DataSourceColumn[]>;
+    query(id: string, q?: DataSourceQuery): Promise<DataSourceQueryResult>;
+    createSource(req: CreateSourceRequest): Promise<DataSourceDefinition>;
+    deleteSource(sourceId: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDataSourceClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultDataSourceClient>;
+}

package/lib/data/data-source-parsers.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceDefinition } from './data-catalog';
+type ParsedRow = Record<string, unknown>;
+export declare function parseJsonArray(raw: string): ParsedRow[];
+export declare function parseCsv(raw: string): ParsedRow[];
+export declare function inferSchema(rows: ParsedRow[]): DataSourceDefinition['schema'];
+export declare function slugifyId(input: string): string;
+export {};

package/lib/data/external-data-source.d.ts

@@ -0,0 +1,29 @@
+export interface ExternalDataSource {
+    datasourceId: number;
+    datasourceName?: string | null;
+    datasourceVersion?: number | null;
+    datasourceDescription?: string | null;
+    /**
+     * External datasource properties payload (often a JSON string).
+     * Expected shape: `{ headerList?: string[]; sampleDataMap?: Record<string, unknown> }`.
+     */
+    dsProperties?: string | Record<string, unknown> | null;
+    type?: string | null;
+    status?: string | null;
+    apiDetails?: unknown;
+    businessClassification?: string | null;
+    createdBy?: string | null;
+    createdTimeStamp?: string | null;
+    customerId?: string | null;
+    environmentList?: unknown;
+    environmentName?: string | null;
+    environmentType?: string | null;
+    jsonUrlProperties?: unknown;
+    searchKey?: string | null;
+    updatedBy?: string | null;
+    updatedTimeStamp?: string | null;
+}
+export interface ExternalDsProperties {
+    headerList?: string[];
+    sampleDataMap?: Record<string, unknown>;
+}

package/lib/data/file-upload-client.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken } from '@angular/core';
+import { UploadedFileRef } from '../form-core/models';
+import * as i0 from "@angular/core";
+export interface FileUploadRequest {
+    endpoint: string;
+    fieldId: string;
+    fieldName: string;
+    fieldKey?: string;
+    headers?: Record<string, string>;
+}
+export interface FileUploadClient {
+    upload(files: File[], request: FileUploadRequest): Promise<UploadedFileRef[]>;
+}
+export declare const FILE_UPLOAD_CLIENT: InjectionToken<FileUploadClient>;
+export declare class DefaultFileUploadClient implements FileUploadClient {
+    upload(files: File[], request: FileUploadRequest): Promise<UploadedFileRef[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFileUploadClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultFileUploadClient>;
+}

package/lib/data/http-data-source-client.d.ts

@@ -0,0 +1,31 @@
+import { InjectionToken, Provider, EnvironmentProviders } from '@angular/core';
+import { DataSourceClient, DataSourceColumn, DataSourceQuery, DataSourceQueryResult, CreateSourceRequest } from './data-source-client';
+import { DataSourceDefinition } from './data-catalog';
+import * as i0 from "@angular/core";
+export interface HttpDataSourceClientConfig {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    cacheTtlMs?: {
+        sources?: number;
+        columns?: number;
+    };
+}
+export declare const HTTP_DATA_SOURCE_CLIENT_CONFIG: InjectionToken<HttpDataSourceClientConfig>;
+export declare class HttpDataSourceClient implements DataSourceClient {
+    private http;
+    private config;
+    private sourceCache;
+    private columnCache;
+    listSources(): Promise<DataSourceDefinition[]>;
+    getSourceById(id: string): Promise<DataSourceDefinition | undefined>;
+    getColumns(id: string): Promise<DataSourceColumn[]>;
+    query(id: string, q?: DataSourceQuery): Promise<DataSourceQueryResult>;
+    createSource(req: CreateSourceRequest): Promise<DataSourceDefinition>;
+    deleteSource(sourceId: string): Promise<void>;
+    private stripTrailingSlash;
+    private mergeHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpDataSourceClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpDataSourceClient>;
+}
+export declare function provideHttpDataSourceClient(config: HttpDataSourceClientConfig): (Provider | EnvironmentProviders)[];

package/lib/data/in-memory-data-catalog.service.d.ts

@@ -0,0 +1,12 @@
+import { DataCatalog, DataSourceDefinition } from './data-catalog';
+import * as i0 from "@angular/core";
+export declare class InMemoryDataCatalogService extends DataCatalog {
+    private sources;
+    listSources(): DataSourceDefinition[];
+    getSourceById(id: string): DataSourceDefinition | undefined;
+    getRows(id: string): any[];
+    upsert(def: DataSourceDefinition, rows: any[]): void;
+    remove(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryDataCatalogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryDataCatalogService>;
+}

package/lib/data/runtime-field-data-access-registry.service.d.ts

@@ -0,0 +1,29 @@
+import type { FormEngine } from '../form-core/form-engine';
+import type { FieldSchema, FormSchema, OptionSchema } from '../form-core/models';
+import { type RuntimeFieldDataAccessContextInput } from './runtime-field-data-access';
+import * as i0 from "@angular/core";
+export declare class RuntimeFieldDataAccessRegistryService {
+    private readonly contexts;
+    register(engine: FormEngine, schema: FormSchema, input: RuntimeFieldDataAccessContextInput): void;
+    unregister(engine: FormEngine): void;
+    hasFieldAccess(field: FieldSchema, engine?: FormEngine): boolean;
+    getOptions(field: FieldSchema, engine?: FormEngine): Promise<OptionSchema[] | undefined>;
+    invalidateFieldAndDescendants(engine: FormEngine, fieldId: string): void;
+    private buildPayload;
+    private resolveExactPath;
+    private getChainTokens;
+    private resolveChainFieldIds;
+    private encodePathSegment;
+    private hasMeaningfulValue;
+    private buildFieldLookup;
+    private normalizeMap;
+    private normalizeDatasourceId;
+    private normalizeFieldList;
+    private normalizeType;
+    private normalizeContentValue;
+    private getCacheKey;
+    private buildDescendantMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeFieldDataAccessRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeFieldDataAccessRegistryService>;
+}
+export type { FieldDataAccessMap, FieldDataAccessMapEntry, RuntimeFieldDataAccessApi, RuntimeFieldDataAccessPayload, RuntimeFieldDataAccessContextInput, RuntimeFieldDataAccessApiOption } from './runtime-field-data-access';

package/lib/data/runtime-field-data-access.d.ts

@@ -0,0 +1,32 @@
+import type { OptionSchema } from '../form-core/models';
+export interface FieldDataAccessMapEntry {
+    chainName: string;
+    datasourceId: string | number;
+    hierarchyAccess: boolean;
+    type?: string;
+    fieldList?: string[];
+    dependentFields?: string[];
+    apiAccess?: boolean;
+    singularDataAccess?: boolean;
+}
+export type FieldDataAccessMap = Record<string, FieldDataAccessMapEntry>;
+export interface RuntimeFieldDataAccessPayload {
+    datasourceId: string | number;
+    formContentId: string;
+    formContentVersion: string;
+    identifier: string;
+    fieldId: string;
+    exactPath?: string;
+}
+export interface RuntimeFieldDataAccessApiOption {
+    label: string;
+    key: string | number;
+}
+export type RuntimeFieldDataAccessApi = (payload: RuntimeFieldDataAccessPayload) => Promise<RuntimeFieldDataAccessApiOption[]>;
+export interface RuntimeFieldDataAccessContextInput {
+    fieldDataAccessMap?: FieldDataAccessMap | null;
+    fieldDataAccessApi?: RuntimeFieldDataAccessApi | null;
+    formContentId?: string | null;
+    formContentVersion?: string | null;
+}
+export declare function normalizeRuntimeOptions(rows: unknown): OptionSchema[];

package/lib/data/tree-utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Utilities for handling tree data structures.
+ */
+export interface TreeNode {
+    id: string;
+    label: string;
+    value: any;
+    data: any;
+    children?: TreeNode[];
+    parent?: TreeNode;
+    expanded?: boolean;
+}
+export interface TreeConfig {
+    idKey: string;
+    parentKey: string;
+    labelKey: string;
+    valueKey: string;
+    rootValue?: any;
+}
+/**
+ * Builds a hierarchical tree from a flat list of rows.
+ */
+export declare function buildTree(rows: any[], config: TreeConfig): TreeNode[];
+/**
+ * Filters a tree structure, returning a new tree with only matching nodes and their ancestors.
+ * Expand matching paths.
+ */
+export declare function filterTree(nodes: TreeNode[], term: string): TreeNode[];

package/lib/email-renderer/email-renderer.component.d.ts

@@ -0,0 +1,21 @@
+import { FormSchema, LayoutNode, WidgetNode, RowNode, ColumnNode } from '../form-core/models';
+import { FormEngine } from '../form-core/form-engine';
+import { WidgetDefinition } from '../widgets/widget-definition';
+import * as i0 from "@angular/core";
+export declare class EmailRendererComponent {
+    schema: FormSchema;
+    engine?: FormEngine;
+    private widgetDefs;
+    constructor(_widgetDefs: WidgetDefinition[][]);
+    isRowNode(node: LayoutNode): node is RowNode;
+    isWidgetNode(node: LayoutNode): node is WidgetNode;
+    get layoutNodes(): RowNode[];
+    getColumns(node: RowNode): ColumnNode[];
+    getColumnWidth(col: ColumnNode, totalColumns: number): number;
+    private renderWidgets;
+    private renderWidget;
+    private renderWidgetToHtml;
+    private getHeadingStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmailRendererComponent, "app-email-renderer", never, { "schema": { "alias": "schema"; "required": true; }; "engine": { "alias": "engine"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/form-core/event-api-reference.d.ts

@@ -0,0 +1,8 @@
+import type { DesignerEventApiDefinition, WidgetEventActionApi } from './models';
+export declare function resolveDesignerEventApiName(api: DesignerEventApiDefinition): string | undefined;
+export declare function resolveDesignerEventApiVersion(api: DesignerEventApiDefinition): string | undefined;
+export declare function resolveActionApiName(action: WidgetEventActionApi): string | undefined;
+export declare function resolveActionApiVersion(action: WidgetEventActionApi): string | undefined;
+export declare function formatActionApiReference(action: WidgetEventActionApi): string;
+export declare function formatDesignerEventApiReference(api: DesignerEventApiDefinition): string;
+export declare function matchesActionToDesignerEventApi(action: WidgetEventActionApi, candidate: DesignerEventApiDefinition): boolean;

package/lib/form-core/form-engine.d.ts

@@ -0,0 +1,55 @@
+import { FormSchema } from './models';
+/**
+ * A framework-agnostic engine to handle form state, validation, and visibility logic.
+ */
+import { Observable } from 'rxjs';
+export interface UiEvent {
+    fieldId: string;
+    fieldName?: string;
+    type: 'focus' | 'blur' | 'change' | 'click' | 'dirty' | 'touched';
+    value?: unknown;
+    ts: number;
+}
+export interface DataSourceUpdateEvent {
+    datasourceId: string;
+    ts: number;
+}
+export declare class FormEngine {
+    private schema;
+    private values;
+    private errors;
+    private ruleEvaluator;
+    private valueSubject;
+    valueChanges$: Observable<Record<string, unknown>>;
+    private eventSubject;
+    events$: Observable<UiEvent>;
+    private dataSourceUpdateSubject;
+    dataSourceUpdates$: Observable<DataSourceUpdateEvent>;
+    private submitSubject;
+    submitted$: Observable<void>;
+    get formGroup(): {
+        value: Record<string, unknown>;
+        valueChanges: Observable<Record<string, unknown>>;
+    };
+    constructor(schema: FormSchema, initialValues?: Record<string, unknown>);
+    getSchema(): FormSchema;
+    updateSchema(schema: FormSchema): void;
+    getValue(fieldName: string): unknown;
+    setValue(fieldName: string, value: unknown): void;
+    getValues(): Record<string, unknown>;
+    getErrors(): Record<string, string[]>;
+    getError(fieldName: string): string | null;
+    emitUiEvent(event: Omit<UiEvent, 'ts'>): void;
+    emitDataSourceUpdate(datasourceId: string): void;
+    submit(): void;
+    validate(): Record<string, string[]>;
+    isFieldVisible(fieldId: string): boolean;
+    isFieldEnabled(fieldId: string): boolean;
+    isFieldRequired(fieldId: string): boolean;
+    private getFieldById;
+    private getFieldByName;
+    private validateField;
+    private evaluateDependencyRules;
+    private evaluateEnterpriseRules;
+}
+export declare function createFormEngine(schema: FormSchema, initialValues?: Record<string, unknown>): FormEngine;

package/lib/form-core/form-event-runner.d.ts

@@ -0,0 +1,28 @@
+import { FormEngine } from './form-engine';
+import { WidgetEventApiExecutor, WidgetEventDatasourceWriter } from './models';
+export interface FormEventLogger {
+    log(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+}
+export interface FormEventRunnerOptions {
+    logger?: FormEventLogger;
+    apiExecutor?: WidgetEventApiExecutor;
+    dataSourceWriter?: WidgetEventDatasourceWriter;
+}
+export declare class FormEventRunner {
+    private engine;
+    private sub;
+    private processingDepth;
+    private readonly logger;
+    private readonly apiExecutor?;
+    private readonly dataSourceWriter?;
+    constructor(engine: FormEngine, loggerOrOptions?: FormEventLogger | FormEventRunnerOptions);
+    dispose(): void;
+    private handleEvent;
+    private executeAction;
+    private handleSetValue;
+    private handleApiAction;
+    private collectSourceValues;
+    private resolveDatasourceId;
+    private normalizeRowsForDatasource;
+}