ngx-form-designer 0.0.6

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,44 @@
+/**
+ * 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;
+}
+/**
+ * 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,58 @@
+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[];
+}
+export declare abstract class DataProvider {
+    abstract getOptions(field: FieldSchema, engine?: FormEngine): Promise<OptionSchema[]>;
+    abstract getList(field: FieldSchema, engine?: FormEngine): Promise<any[]>;
+    abstract getValue(field: FieldSchema, engine?: FormEngine): Promise<any>;
+    abstract resolveValue(field: FieldSchema, value: any): Promise<string>;
+    queryOptions(field: FieldSchema, query: {
+        term: string;
+        limit?: number;
+    }, engine?: FormEngine): Promise<any[]>;
+    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: any[];
+    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;
+    getOptions(field: FieldSchema, engine?: FormEngine): Promise<OptionSchema[]>;
+    queryOptions(field: FieldSchema, query: OptionsQuery, engine?: FormEngine): Promise<OptionSchema[]>;
+    getList(field: FieldSchema, engine?: FormEngine): Promise<any[]>;
+    queryList(field: FieldSchema, query: ListQuery, engine?: FormEngine): Promise<ListResult>;
+    getValue(field: FieldSchema, engine?: FormEngine): Promise<any>;
+    resolveValue(field: FieldSchema, value: any): Promise<string>;
+    private getRawRows;
+    private getGlobalRows;
+    private applyRowFilters;
+    private resolveFilters;
+    private resolveFilterValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDataProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultDataProvider>;
+}

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,5 @@
+import { DataSourceDefinition } from './data-catalog';
+export declare function parseJsonArray(raw: string): any[];
+export declare function parseCsv(raw: string): any[];
+export declare function inferSchema(rows: any[]): DataSourceDefinition['schema'];
+export declare function slugifyId(input: string): string;

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/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/form-engine.d.ts

@@ -0,0 +1,48 @@
+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?: any;
+    ts: number;
+}
+export declare class FormEngine {
+    private schema;
+    private values;
+    private errors;
+    private ruleEvaluator;
+    private valueSubject;
+    valueChanges$: Observable<Record<string, any>>;
+    private eventSubject;
+    events$: Observable<UiEvent>;
+    private submitSubject;
+    submitted$: Observable<void>;
+    get formGroup(): {
+        value: Record<string, any>;
+        valueChanges: Observable<Record<string, any>>;
+    };
+    constructor(schema: FormSchema, initialValues?: Record<string, any>);
+    getSchema(): FormSchema;
+    updateSchema(schema: FormSchema): void;
+    getValue(fieldName: string): any;
+    setValue(fieldName: string, value: any): void;
+    getValues(): Record<string, any>;
+    getErrors(): Record<string, string[]>;
+    getError(fieldName: string): string | null;
+    emitUiEvent(event: Omit<UiEvent, 'ts'>): 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, any>): FormEngine;

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

@@ -0,0 +1,15 @@
+import { FormEngine } from './form-engine';
+export interface FormEventLogger {
+    log(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+}
+export declare class FormEventRunner {
+    private engine;
+    private logger;
+    private sub;
+    private processingDepth;
+    constructor(engine: FormEngine, logger?: FormEventLogger);
+    dispose(): void;
+    private handleEvent;
+    private handleSetValue;
+}

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

@@ -0,0 +1,255 @@
+export type FieldType = 'text' | 'textarea' | 'number' | 'email' | 'password' | 'tel' | 'date' | 'time' | 'datetime-local' | 'checkbox' | 'radio' | 'select' | 'multiselect' | 'file' | 'image' | 'heading' | 'paragraph' | 'cta-button' | 'table' | (string & {});
+export interface Html5ValidationProps {
+    required?: boolean;
+    min?: number | string;
+    max?: number | string;
+    step?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+export interface ValidationRule {
+    id?: string;
+    type: 'builtin' | 'expression';
+    name?: string;
+    expression?: string;
+    message: string;
+    when?: string;
+}
+export type LogicOperator = 'AND' | 'OR';
+export type ConditionOperator = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'startsWith' | 'endsWith' | 'empty' | 'notEmpty' | 'truthy';
+export type RuleAction = 'visible' | 'hidden' | 'enable' | 'disable' | 'required' | 'optional';
+export interface LogicCondition {
+    fieldId: string;
+    operator: ConditionOperator;
+    value?: any;
+}
+export interface LogicGroup {
+    operator: LogicOperator;
+    conditions: (LogicCondition | LogicGroup)[];
+}
+export interface FormRule {
+    id: string;
+    name?: string;
+    conditions: LogicGroup;
+    action: RuleAction;
+}
+export interface WidgetStyleSchema {
+    width?: string | number;
+    height?: string | number;
+    minWidth?: string | number;
+    minHeight?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    alignX?: 'left' | 'center' | 'right' | 'stretch';
+    alignY?: 'top' | 'middle' | 'bottom' | 'stretch';
+    margin?: string;
+    marginTop?: string | number;
+    marginRight?: string | number;
+    marginBottom?: string | number;
+    marginLeft?: string | number;
+    padding?: string;
+    paddingTop?: string | number;
+    paddingRight?: string | number;
+    paddingBottom?: string | number;
+    paddingLeft?: string | number;
+    backgroundColor?: string;
+    color?: string;
+    borderRadius?: string | number;
+    borderWidth?: string | number;
+    borderColor?: string;
+    borderStyle?: 'solid' | 'dashed' | 'dotted' | 'none';
+    fontSize?: string | number;
+    fontWeight?: string | number;
+    lineHeight?: string | number;
+    textAlign?: 'left' | 'center' | 'right' | 'justify';
+    transformX?: number;
+    transformY?: number;
+    transformZ?: number;
+    rotate?: number;
+    scale?: number;
+    opacity?: number;
+    boxShadow?: string;
+    [key: string]: any;
+}
+export interface UploadedFileRef {
+    id?: string;
+    name?: string;
+    size?: number;
+    type?: string;
+    url?: string;
+}
+export type FileUploadValue = UploadedFileRef | UploadedFileRef[] | null;
+export interface FieldSchema {
+    id: string;
+    widgetId?: string;
+    name: string;
+    type: FieldType;
+    groupKey?: string;
+    label?: string;
+    placeholder?: string;
+    helpText?: string;
+    tooltip?: string;
+    defaultValue?: any;
+    accept?: string;
+    multiple?: boolean;
+    uploadUrl?: string;
+    uploadFieldName?: string;
+    appearance?: 'outline' | 'fill' | 'standard';
+    readonly?: boolean;
+    disabled?: boolean;
+    prefixIcon?: string;
+    suffixIcon?: string;
+    html5?: Html5ValidationProps;
+    validation?: ValidationRule[];
+    dependencies?: DependencyRule[];
+    conditionalVisibility?: ConditionalVisibility;
+    rules?: FormRule[];
+    dataConfig?: DataSourceConfig;
+    events?: WidgetEventBinding[];
+    dataSourceId?: string;
+    staticOptions?: OptionSchema[];
+    style?: WidgetStyleSchema;
+    metadata?: Record<string, unknown>;
+    [key: string]: any;
+}
+export interface DataSourceConfig {
+    type: 'static' | 'api' | 'context' | 'global' | 'source';
+    staticValue?: any;
+    staticOptions?: OptionSchema[];
+    endpoint?: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    resultPath?: string;
+    labelKey?: string;
+    valueKey?: string;
+    contextKey?: string;
+    sourceId?: string;
+    dependsOn?: DataDependencyBinding[];
+    filters?: DataFilter[];
+    treeIdKey?: string;
+    treeParentKey?: string;
+    treeRootValue?: any;
+    searchEnabled?: boolean;
+    searchColumns?: string[];
+    optionsLimit?: number;
+    pageSize?: number;
+    sort?: {
+        column: string;
+        dir: 'asc' | 'desc';
+    }[];
+}
+export type DataFilterOperator = 'eq' | 'neq' | 'in' | 'contains' | 'startsWith' | 'endsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'like';
+export interface DataFilter {
+    column: string;
+    op: DataFilterOperator;
+    valueFrom?: 'field' | 'literal';
+    fieldId?: string;
+    valueLiteral?: any;
+}
+export type WidgetEventType = 'focus' | 'blur' | 'change' | 'click' | 'dirty' | 'touched';
+export interface WidgetEventActionSetValue {
+    type: 'setValue';
+    targetFieldId: string;
+    valueFrom: 'literal' | 'field' | 'event';
+    valueLiteral?: any;
+    sourceFieldId?: string;
+}
+export interface WidgetEventActionLog {
+    type: 'log';
+    message?: string;
+}
+export type WidgetEventAction = WidgetEventActionSetValue | WidgetEventActionLog;
+export interface WidgetEventBinding {
+    id: string;
+    on: WidgetEventType;
+    enabled?: boolean;
+    actions: WidgetEventAction[];
+}
+export interface DataDependencyBinding {
+    fieldId: string;
+    paramKey: string;
+}
+export interface ConditionalVisibility {
+    fieldName: string;
+    operator: 'equals' | 'notEquals' | 'contains' | 'isEmpty' | 'isNotEmpty' | 'greaterThan' | 'lessThan';
+    value?: any;
+}
+export interface OptionSchema {
+    label: string;
+    value: string | number;
+}
+export interface DependencyRule {
+    effect: 'show' | 'hide' | 'enable' | 'disable' | 'require' | 'optional';
+    when: string;
+}
+export type WidgetKind = 'field' | 'image' | 'text' | 'table' | 'button';
+export interface ResponsiveSpan {
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    '2xl'?: number;
+}
+export type LayoutNode = RowNode | ColumnNode | WidgetNode;
+export interface BaseNode {
+    id: string;
+    type: 'row' | 'col' | 'widget';
+    style?: StyleTokenSet;
+    parent?: string;
+}
+export interface RowNode extends BaseNode {
+    type: 'row';
+    children: ColumnNode[];
+    maxColumns?: number;
+}
+export interface ColumnNode extends BaseNode {
+    type: 'col';
+    responsive: ResponsiveSpan;
+    children: LayoutNode[];
+}
+export interface WidgetNode extends BaseNode {
+    type: 'widget';
+    widgetKind: WidgetKind;
+    refId: string;
+}
+export type SpacingToken = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface StyleTokenSet {
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    textAlign?: 'left' | 'center' | 'right';
+    padding?: SpacingToken | string;
+    margin?: SpacingToken | string;
+    borderRadius?: string;
+    borderColor?: string;
+    backgroundColor?: string;
+    minHeight?: string;
+    marginBottom?: SpacingToken | string;
+    gap?: SpacingToken | string;
+    width?: string;
+    height?: string;
+    [key: string]: any;
+}
+export interface FormUIConfig {
+    themeId?: string;
+    baseStyle?: StyleTokenSet;
+}
+export type DesignerFlavor = 'form' | 'web' | 'email' | 'pdf';
+export declare const CURRENT_SCHEMA_VERSION = "1.0.0";
+export interface FormSchema {
+    id: string;
+    version: string;
+    schemaVersion?: string;
+    flavor?: DesignerFlavor;
+    title?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    fields: FieldSchema[];
+    layout: LayoutNode;
+    ui?: FormUIConfig;
+    submitButtonText?: string;
+    resetButtonText?: string;
+    showResetButton?: boolean;
+}

package/lib/form-core/plugin-metadata.d.ts

@@ -0,0 +1,10 @@
+import { FormSchema, FieldSchema } from './models';
+/**
+ * Helper methodology for plugins to store JSON data on the schema/fields.
+ * pluginId should be the same ID used in DesignerPlugin.id and in defineWidget(pluginId, ...).
+ * This keeps everything portable and AI-friendly.
+ */
+export declare function getPluginSchemaMeta<T = unknown>(schema: FormSchema, pluginId: string): T | undefined;
+export declare function setPluginSchemaMeta<T = unknown>(schema: FormSchema, pluginId: string, value: T): FormSchema;
+export declare function getPluginFieldMeta<T = unknown>(field: FieldSchema, pluginId: string): T | undefined;
+export declare function setPluginFieldMeta<T = unknown>(field: FieldSchema, pluginId: string, value: T): FieldSchema;

package/lib/form-core/rule-evaluation.service.d.ts

@@ -0,0 +1,18 @@
+import { FormRule } from './models';
+import * as i0 from "@angular/core";
+export declare class RuleEvaluationService {
+    constructor();
+    /**
+     * Evaluates a single rule against the current form data.
+     * Returns true if the rule's conditions are met.
+     */
+    evaluateRule(rule: FormRule, formData: any): boolean;
+    /**
+     * Recursively evaluates a LogicGroup (AND/OR).
+     */
+    private evaluateGroup;
+    private evaluateConditionOrGroup;
+    private evaluateCondition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleEvaluationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuleEvaluationService>;
+}

package/lib/form-core/schema-factory.d.ts

@@ -0,0 +1,11 @@
+import { FormSchema, DesignerFlavor } from './models';
+/**
+ * Metadata field is intended for AI/LLM and project-level information (prompts, generation parameters, tags).
+ * SchemaVersion will be used for future migrations as more flavors (audio/video/image editors, tables, etc.) are added.
+ */
+export declare function createEmptySchema(flavor?: DesignerFlavor, opts?: {
+    title?: string;
+    id?: string;
+}): FormSchema;
+export declare function serializeSchema(schema: FormSchema): string;
+export declare function parseSchema(json: string): FormSchema;

package/lib/form-core/schema-guard.d.ts

@@ -0,0 +1,18 @@
+import { FormSchema } from './models';
+export interface SchemaGuardIssue {
+    level: 'warn' | 'error';
+    message: string;
+    fieldId?: string;
+    fieldName?: string;
+}
+/**
+ * Checks the schema for violations of the "API-Only Source" architecture.
+ * This is a read-only check that does not mutate the schema.
+ */
+export declare function checkSchemaForApiOnlySources(schema: FormSchema): SchemaGuardIssue[];
+/**
+ * Manually sanitizes a schema by removing embedded data from source-backed fields.
+ * Returns a deep copy of the modified schema.
+ * use this for debugging only.
+ */
+export declare function stripEmbeddedSourceData(schema: FormSchema): FormSchema;