ngx-form-designer 0.0.23

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

@@ -0,0 +1,358 @@
+export type FieldType = 'text' | 'textarea' | 'number' | 'email' | 'password' | 'tel' | 'date' | 'time' | 'datetime-local' | 'checkbox' | 'radio' | 'select' | 'multiselect' | 'file' | 'repeatable-group' | '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?: unknown;
+}
+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]: unknown;
+}
+export interface UploadedFileRef {
+    id?: string;
+    name?: string;
+    size?: number;
+    type?: string;
+    url?: string;
+}
+export type FileUploadValue = UploadedFileRef | UploadedFileRef[] | null;
+export interface RepeatableGroupConfig {
+    minItems?: number;
+    maxItems?: number;
+    itemLabel?: string;
+    addButtonLabel?: string;
+    removeButtonLabel?: string;
+    itemSchema: FormSchema;
+}
+export interface FieldSchema {
+    id: string;
+    widgetId?: string;
+    name: string;
+    type: FieldType;
+    groupKey?: string;
+    label?: string;
+    placeholder?: string;
+    helpText?: string;
+    tooltip?: string;
+    defaultValue?: unknown;
+    accept?: string;
+    multiple?: boolean;
+    uploadUrl?: string;
+    uploadFieldName?: string;
+    repeatable?: RepeatableGroupConfig;
+    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]: unknown;
+}
+export interface DataSourceConfig {
+    type: 'static' | 'api' | 'context' | 'global' | 'source';
+    staticValue?: unknown;
+    staticOptions?: OptionSchema[];
+    endpoint?: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    resultPath?: string;
+    labelKey?: string;
+    valueKey?: string;
+    contextKey?: string;
+    datasourceId?: string;
+    rowsPath?: string;
+    labelPath?: string;
+    valuePath?: string;
+    rowSelectionMode?: 'first' | 'selected';
+    selectionFieldId?: string;
+    selectionMatchPath?: string;
+    childRowsPath?: string;
+    dependsOn?: DataDependencyBinding[];
+    filters?: DataFilter[];
+    hierarchyAccess?: boolean;
+    eventAccess?: boolean;
+    eventId?: string;
+    treeIdKey?: string;
+    treeParentKey?: string;
+    treeRootValue?: unknown;
+    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?: unknown;
+}
+export type WidgetEventType = 'focus' | 'blur' | 'change' | 'click' | 'dirty' | 'touched';
+export interface WidgetEventActionSetValue {
+    type: 'setValue';
+    targetFieldId: string;
+    valueFrom: 'literal' | 'field' | 'event';
+    valueLiteral?: unknown;
+    sourceFieldId?: string;
+}
+export interface WidgetEventActionLog {
+    type: 'log';
+    message?: string;
+}
+export interface WidgetEventActionApi {
+    type: 'api';
+    apiId?: string;
+    apiName?: string;
+    apiVersion?: string;
+    datasourceId?: string;
+    sourceFieldIds?: string[];
+    inputTransformScript?: string;
+    outputTransformScript?: string;
+}
+export type WidgetEventAction = WidgetEventActionSetValue | WidgetEventActionLog | WidgetEventActionApi;
+export interface WidgetEventApiExecutionRequest {
+    eventId: string;
+    action: WidgetEventActionApi;
+    event: {
+        fieldId: string;
+        fieldName?: string;
+        type: WidgetEventType;
+        value?: unknown;
+        ts: number;
+    };
+    input: unknown;
+    sourceValues: Record<string, unknown>;
+    formValues: Record<string, unknown>;
+}
+export type WidgetEventApiExecutor = (request: WidgetEventApiExecutionRequest) => Promise<unknown>;
+export interface WidgetEventDatasourceWriteRequest {
+    datasourceId: string;
+    rows: unknown[];
+    action: WidgetEventActionApi;
+    event: {
+        fieldId: string;
+        fieldName?: string;
+        type: WidgetEventType;
+        value?: unknown;
+        ts: number;
+    };
+    response: unknown;
+}
+export type WidgetEventDatasourceWriter = (request: WidgetEventDatasourceWriteRequest) => void | Promise<void>;
+export interface WidgetEventBinding {
+    id: string;
+    on: WidgetEventType;
+    enabled?: boolean;
+    actions: WidgetEventAction[];
+}
+export interface DesignerEventApiDefinition {
+    id?: string;
+    name?: string;
+    version?: string;
+    label: string;
+    endpoint?: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+export interface DesignerEventApiSearchRequest {
+    pageNo: number;
+    itemsPerPage: number;
+}
+export interface DesignerEventApiSearchResponse {
+    items: DesignerEventApiDefinition[];
+    hasMore?: boolean;
+    totalItems?: number;
+}
+export interface DesignerEventApiSchemaRequest {
+    apiName: string;
+    apiVersion?: string;
+    apiId?: string;
+}
+export interface DesignerEventApiSchemaResponse {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+export interface DesignerEventApiBrowser {
+    search(request: DesignerEventApiSearchRequest): Promise<DesignerEventApiSearchResponse>;
+    getSchema?(request: DesignerEventApiSchemaRequest): Promise<DesignerEventApiSchemaResponse>;
+}
+export interface EventFieldConfigSnapshot {
+    fieldId: string;
+    fieldName: string;
+    fieldLabel?: string;
+    scopePath: string[];
+    events: WidgetEventBinding[];
+}
+export interface EventsWorkspaceSavePayload {
+    selectedFieldId: string | null;
+    selectedFieldEvents: WidgetEventBinding[];
+    fields: EventFieldConfigSnapshot[];
+}
+export interface DataDependencyBinding {
+    fieldId: string;
+    paramKey: string;
+}
+export interface ConditionalVisibility {
+    fieldName: string;
+    operator: 'equals' | 'notEquals' | 'contains' | 'isEmpty' | 'isNotEmpty' | 'greaterThan' | 'lessThan';
+    value?: unknown;
+}
+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]: unknown;
+}
+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: Record<string, unknown>): 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;

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

@@ -0,0 +1,9 @@
+import { FormSchema } from './models';
+/**
+ * Automatically computes and sets `hierarchyAccess` flags
+ * on each field's dataConfig based on dependency relationships.
+ *
+ * Logic:
+ * - hierarchyAccess = true if field has dependsOn OR other fields depend on it
+ */
+export declare function computeAccessFlags(schema: FormSchema): void;

package/lib/form-designer/data-panel/data-panel.component.d.ts

@@ -0,0 +1,101 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { FieldSchema, OptionSchema, DataDependencyBinding, DataFilter } from '../../form-core/models';
+import { DataSourceDefinition } from '../../data/data-catalog';
+import { DataSourceColumn } from '../../data/data-source-client';
+import * as i0 from "@angular/core";
+export declare class DataPanelComponent implements OnChanges {
+    config: FieldSchema;
+    readOnly: boolean;
+    dataConsumer: 'value' | 'list' | 'image' | 'none';
+    bindingShape: 'scalar' | 'list' | null;
+    widgetType: string;
+    allFields: FieldSchema[];
+    configChange: EventEmitter<FieldSchema>;
+    sourceType: 'static' | 'source';
+    selectedSourceId?: string;
+    showSourceManager: boolean;
+    staticOptions: OptionSchema[];
+    labelKey?: string;
+    valueKey?: string;
+    rowsPath?: string;
+    rowsPathSuggestion?: string;
+    rowSelectionMode: 'first' | 'selected';
+    selectionFieldId?: string;
+    selectionMatchPath?: string;
+    childRowsPath?: string;
+    rootPathOptions: string[];
+    rowPathOptions: string[];
+    staticValue?: any;
+    tableColumns: any[];
+    tableRows: any[];
+    dependencyBindings: DataDependencyBinding[];
+    dataFilters: DataFilter[];
+    availableSources: DataSourceDefinition[];
+    sourceColumns: DataSourceColumn[];
+    previewLoading: boolean;
+    previewError: string | null;
+    previewRows: unknown[];
+    previewTotal: number;
+    private previewReqId;
+    private client;
+    constructor();
+    searchEnabled: boolean;
+    optionsLimit?: number;
+    searchColumns: string[];
+    treeIdKey?: string;
+    treeParentKey?: string;
+    treeRootValue?: string;
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    refreshSources(): Promise<void>;
+    openSourceManager(): void;
+    closeSourceManager(): void;
+    get availableFields(): FieldSchema[];
+    setSourceType(type: 'static' | 'source'): void;
+    addOption(): void;
+    removeOption(index: number): void;
+    onSourceChange(): void;
+    onMappingKeyChange(): void;
+    loadSourceInfo(): Promise<void>;
+    refreshPreview(): Promise<void>;
+    autoMapKeys(): void;
+    hasFieldFilters(): boolean;
+    updateSearchColumns(value: string): void;
+    addTableColumn(): void;
+    removeTableColumn(index: number): void;
+    addTableRow(): void;
+    removeTableRow(index: number): void;
+    addDependency(): void;
+    removeDependency(index: number): void;
+    addFilter(): void;
+    removeFilter(index: number): void;
+    private resetEditorState;
+    loadFromField(): void;
+    emitChange(): void;
+    generateTableColumns(): Promise<void>;
+    pageSize?: number;
+    sortColumn?: string;
+    sortDir: 'asc' | 'desc';
+    toggleSortDir(): void;
+    formatSourceLabel(source: DataSourceDefinition & {
+        eventAccess?: boolean;
+    }): string;
+    isSelectedSourceEventBacked(): boolean;
+    normalizedRowsPath(): string | undefined;
+    effectiveRowsPath(): string | undefined;
+    useSuggestedRowsPath(): void;
+    showRowsPathControls(): boolean;
+    showScalarMappingControls(): boolean;
+    rowsPathPreviewRows(): unknown[];
+    getPreviewLabel(row: any): string;
+    getPreviewValue(row: any): string;
+    availableRootPaths(): string[];
+    availableRowPaths(): string[];
+    availableParentRowPaths(): string[];
+    availableChildCollectionPaths(): string[];
+    private shouldPersistStructuredLabelPath;
+    private shouldPersistStructuredValuePath;
+    private updatePreviewPathState;
+    private extractPreviewRows;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataPanelComponent, "app-data-panel", never, { "config": { "alias": "config"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "dataConsumer": { "alias": "dataConsumer"; "required": false; }; "bindingShape": { "alias": "bindingShape"; "required": false; }; "widgetType": { "alias": "widgetType"; "required": false; }; "allFields": { "alias": "allFields"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
+}

package/lib/form-designer/designer-context.service.d.ts

@@ -0,0 +1,29 @@
+import { Signal } from '@angular/core';
+import { FormSchema, FieldSchema } from '../form-core/models';
+import { WidgetDefinition } from '../widgets/widget-definition';
+import { DesignerPlugin } from '../plugins/designer-plugin';
+import * as i0 from "@angular/core";
+/**
+ * Public API for Designer Plugins.
+ * Allows plugins to interact with the designer state and discover other plugins.
+ */
+export declare class DesignerContext {
+    private readonly state;
+    private readonly pluginGroups;
+    readonly schema: Signal<FormSchema>;
+    readonly plugins: Signal<DesignerPlugin[]>;
+    getSchema(): FormSchema;
+    updateSchema(mutator: (schema: FormSchema) => FormSchema): void;
+    getFields(): FieldSchema[];
+    getFieldById(id: string): FieldSchema | undefined;
+    updateField(id: string, updater: (field: FieldSchema) => FieldSchema): void;
+    getPluginSchemaMeta<T = unknown>(pluginId: string): T | undefined;
+    setPluginSchemaMeta<T = unknown>(pluginId: string, value: T): void;
+    getPluginFieldMeta<T = unknown>(fieldId: string, pluginId: string): T | undefined;
+    setPluginFieldMeta<T = unknown>(fieldId: string, pluginId: string, value: T): void;
+    getWidgetDefinitionById(id: string): WidgetDefinition | undefined;
+    getWidgetDefinitionForField(field: FieldSchema, kind?: string): WidgetDefinition | undefined;
+    getWidgetDefinition(type: string): WidgetDefinition | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DesignerContext>;
+}