@spring-systems/core 0.8.0

package/dist/events/index.js

@@ -0,0 +1,12 @@
+import {
+  eventBus
+} from "../chunk-OSSX443T.js";
+import "../chunk-S6RPCN5H.js";
+import "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  eventBus
+};
+//# sourceMappingURL=index.js.map

package/dist/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/form-types-D3MdGpjA.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Shared types used by both List and TreeList grids.
+ * Single source of truth — re-exported from lists.ts and treelists.ts.
+ * @module grid-types
+ */
+interface Permission {
+    delete: boolean;
+    insert: boolean;
+    list: boolean;
+    read: boolean;
+    update: boolean;
+    /** Allows projects to add custom permission fields (e.g., { export: true, approve: false }) */
+    [key: string]: boolean;
+}
+type LogicOperator = "and" | "or";
+/** Node structure for tree-based filter. */
+interface FilterNode {
+    field?: string;
+    operator?: string;
+    value?: string | number | boolean | null;
+    logic?: LogicOperator;
+    filters?: FilterNode[];
+    negate?: boolean;
+}
+/** Simple key-value system filter (normalized into FilterNode by the engine). */
+interface SystemFilterRecord {
+    [key: string]: string | number | boolean | Date | null | undefined;
+}
+type ColumnType = "string" | "number" | "date" | "datetime" | "time" | "boolean" | "object" | "color";
+/** Column layout for saving into user settings. */
+interface ColumnLayout {
+    key: string;
+    order: number;
+    width?: number;
+    show: boolean;
+}
+interface DefaultFilter {
+    domain_name: string;
+    id_public: string;
+    is_default: boolean;
+    json_data: string;
+    name: string;
+    user_setting_type_code: "user" | "fixed" | "layout";
+    version: number;
+}
+interface SavedLayout {
+    domain_name: string;
+    id_public: string;
+    is_default: boolean;
+    json_data: string;
+    name: string;
+    user_setting_type_code: "layout";
+    version: number;
+}
+/** Combined structure for json_data in user-settings — filter + layout in one JSON. */
+interface CombinedSettingData {
+    user_filter?: FilterNode | null;
+    layout?: ColumnLayout[];
+}
+/** Type guard for FilterNode — checks for tree-filter or leaf-filter shape. */
+declare function isFilterNode(val: unknown): val is FilterNode;
+/** Type guard for CombinedSettingData — checks for user_filter or layout property. */
+declare function isCombinedSettingData(val: unknown): val is CombinedSettingData;
+/** Type guard for Permission — checks for all 5 required CRUD boolean keys. */
+declare function isPermission(val: unknown): val is Permission;
+/** Type guard for ColumnLayout — checks for required key, order, show properties. */
+declare function isColumnLayout(val: unknown): val is ColumnLayout;
+
+/**
+ * Types for FormManager - runtime shapes of fields, details, and store API.
+ * @module form-types
+ */
+
+/** Concrete union type for form field values (JSON-like data from API) */
+type FormDataValue = string | number | boolean | Date | null | undefined | FormDataValue[] | {
+    [key: string]: FormDataValue;
+};
+/**
+ * Form field value — at runtime includes: string, number, boolean, Date, null, undefined,
+ * arrays, plain objects (JSON data from API). TS interface limitation: cannot be expressed as a union
+ * without losing compatibility with TS interfaces (they lack implicit index signatures).
+ */
+type FormFieldValue = unknown;
+/** Zustand store state — top-level keys (detail, list, ...) */
+interface FormStoreState {
+    [key: string]: FormFieldValue;
+}
+/** Indexable object with FormDataValue entries — concrete type for dynamic field access in utilities */
+interface IndexedFormData {
+    [key: string]: FormDataValue;
+}
+/** Indexable object — concrete type for generic object traversal (deepCopy, tree access) */
+interface Indexable {
+    [key: string]: FormDataValue;
+}
+/** Plain object of a collection item — with known meta keys */
+interface FormCollectionItem {
+    __cid?: string;
+    id_public?: string;
+    [key: string]: FormDataValue;
+}
+/** Map of form fields — fieldName -> FormFieldRuntime */
+interface FormDetailFields {
+    [key: string]: FormFieldRuntime;
+}
+/** Structure definition for a nested object/collection */
+interface FormStructureDef {
+    [key: string]: FormFieldDefinitionRuntime;
+}
+/** Forward declaration for FormManagerImpl - avoids circular dependency */
+interface FormManagerRef {
+    handleForm: <_T>(setState: (updater: (state: FormStoreState) => FormStoreState) => void, collectionKeys?: string[] | string, isFilter?: boolean) => FormCollectionActions;
+}
+/** Runtime shape of a field definition in structure (metadata without value) */
+interface FormFieldDefinitionRuntime {
+    value?: FormDataValue;
+    title?: string | ((item: FormCollectionItem) => string);
+    resourceKey?: string;
+    validation?: string | ((value: FormDataValue, structure: FormDetailFields) => string);
+    required?: (structure: FormDetailFields) => boolean;
+    skipValidation?: boolean;
+    skipField?: boolean;
+    help?: string;
+    dataSource?: FormDataValue[];
+    visible?: (structure: FormDetailFields) => boolean;
+    disabled?: (structure: FormDetailFields) => boolean;
+    onChange?: (value: FormDataValue, formManager: FormManagerRef) => void;
+    [key: string]: FormFieldValue;
+}
+/** Core field identity and value. */
+interface FormFieldCore {
+    value?: FormDataValue;
+    items?: FormCollectionItem[];
+    structure?: FormStructureDef;
+    title?: string | ((item: FormCollectionItem) => string);
+    resourceKey?: string;
+    key?: string;
+    help?: string;
+    dataSource?: FormDataValue[];
+}
+/** Validation facet of a form field. */
+interface FormFieldValidation {
+    validation?: string | ((value: FormDataValue, structure: FormDetailFields) => string);
+    required?: (structure: FormDetailFields) => boolean;
+    skipValidation?: boolean;
+    skipField?: boolean;
+    serverError?: string;
+    forceDefault?: boolean;
+}
+/** Mutation methods for form fields. */
+interface FormFieldMutation {
+    set?: (newValue: FormDataValue, index?: number, fieldName?: string) => void;
+    add?: (parent: FormCollectionItem | null, defaultValue?: FormCollectionItem) => void;
+    remove?: (item: FormCollectionItem) => void;
+}
+/** Lifecycle hooks for form fields (collection items, change events). */
+interface FormFieldLifecycle {
+    onChange?: (value: FormDataValue, formManager: FormManagerRef) => void;
+    onBeforeAdd?: (newItem: FormCollectionItem) => FormCollectionItem | undefined;
+    onAfterAdd?: (addedItem: FormCollectionItem, allItems: FormCollectionItem[]) => void;
+    onBeforeRemove?: (item: FormCollectionItem) => boolean | void;
+    onAfterRemove?: (removedItem: FormCollectionItem) => void;
+}
+/** Visibility facet of a form field. */
+interface FormFieldVisibility {
+    visible?: (structure: FormDetailFields) => boolean;
+    disabled?: (structure: FormDetailFields) => boolean;
+}
+/** Runtime shape of a single form field — intersection of all facets. 100% backward-compatible. */
+interface FormFieldRuntime extends FormFieldCore, FormFieldValidation, FormFieldMutation, FormFieldLifecycle, FormFieldVisibility {
+    [key: string]: FormFieldValue;
+}
+type FormChangedPath = string;
+interface FormChangesSnapshot {
+    isChanged: boolean;
+    changedPaths: FormChangedPath[];
+    lastChangedPath?: FormChangedPath;
+}
+interface FormChangesApi {
+    get(): FormChangesSnapshot;
+    isChanged(path: FormChangedPath): boolean;
+    markClean(): void;
+    touch(path: FormChangedPath, previousValue: FormDataValue, currentValue: FormDataValue): void;
+    setChanged(path: FormChangedPath, changed: boolean): void;
+    exportBaseline?: () => FormStoreState;
+    importBaseline?: (baseline: FormStoreState) => void;
+}
+/** Runtime state of the entire form detail - access to fields via string index, specific runtime keys */
+interface FormDetailRuntime extends FormStoreState {
+    isEdited?: boolean;
+    isValidated?: boolean;
+    changes?: FormChangesApi;
+    formManager?: FormManagerRef;
+    form?: (collectionKeys?: string | string[]) => FormCollectionActions;
+}
+/** Minimal interface for createForm return value — Zustand store instance. */
+interface FormStoreInstance {
+    getState: () => object;
+}
+/** Type for the Zustand-like store used by FormManager */
+interface FormStoreApi {
+    getState: () => FormStoreState;
+    setState: (updater: (s: FormStoreState) => FormStoreState) => void;
+    getInitialState: () => FormStoreState;
+}
+/** Actions for manipulating collections in the form (add/remove/set) */
+interface FormCollectionActions {
+    add: (parent: FormCollectionItem | null, newItem: FormCollectionItem) => void;
+    remove: (itemToRemove: FormCollectionItem) => void;
+    set: (newValue: FormFieldValue, key: string, item: FormCollectionItem) => void;
+}
+/** Non-generic version of FormManager for contexts where invariant M is not needed. */
+interface FormManagerBase {
+    clearFields(): void;
+    getFields(): (FormStoreState & {
+        id_public?: string;
+    }) | null;
+    setFields(value: FormStoreState, opts?: {
+        markClean?: boolean;
+    }): void;
+    get(key: string): FormFieldValue;
+    set(key: string, value: FormFieldValue): void;
+    getReadOnly(): boolean;
+    setReadOnly(value: boolean): void;
+    setIdPublic(value: string): void;
+    validate(): boolean;
+    save(url: string, fields: FormStoreState & {
+        id_public?: string;
+    }, validations?: boolean): Promise<FormStoreState | false>;
+    load<T extends FormStoreState>(route: string, id_public?: string, detailData?: T, copyFrom?: string): Promise<T | undefined>;
+    getPermissions(): Permission | undefined;
+    setPermissions(permissions: Permission | undefined): void;
+    transformDs(items: FormCollectionItem[], structure?: FormStructureDef): FormCollectionItem[];
+    handleForm<_T>(setState: (updater: (state: FormStoreState) => FormStoreState) => void, collectionKeys?: string[] | string, isFilter?: boolean): FormCollectionActions;
+}
+/** Minimal interface for ListManager — covers .load() called from Detail/Context. */
+interface ListManagerLoadable {
+    load(allowLoad?: boolean): Promise<object | null | undefined | void>;
+    highlightRow(id_public: string): void;
+}
+/** Form readOnly state — minimal interface for the readOnly field in FormPageForm */
+interface ReadOnlyField {
+    value?: boolean;
+    set?: (newValue: boolean) => void;
+}
+interface Identifiable {
+    id_public?: string | number;
+    id?: string | number;
+    [key: string]: FormFieldValue;
+}
+/** Extracts ID from an object — looks for `key`, `id_public`, `id` (in that order). */
+declare function getIdentifiableId(obj: unknown, key?: string): string | number | undefined;
+/** Zustand boundary cast — encapsulates `as unknown as T` for Store type invariance. */
+declare function storeBoundary<T>(value: FormFieldValue): T;
+/** Boundary function: narrows FormFieldValue (=unknown) to FormDataValue at the unknown→typed boundary. */
+declare function toFormDataValue(value: FormFieldValue): FormDataValue;
+/** Type guard: checks if an unknown value is a FormFieldRuntime-like object (has `value` key and is not a Date/Array). */
+declare function isFormFieldRuntime(val: unknown): val is FormFieldRuntime;
+/** Typed accessor: returns FormFieldRuntime from FormStoreState[key] with a runtime type check. */
+declare function getField(state: FormStoreState | null | undefined, key: string): FormFieldRuntime | undefined;
+/** Typed accessor: returns nested FormStoreState from FormStoreState[key] with a runtime check. */
+declare function getSubState(state: FormStoreState | null | undefined, key: string): FormStoreState | undefined;
+/** Typed accessor: returns a value from Zustand store state under the given key. */
+declare function getStoreValue<T>(state: object, key: string): T;
+/** Filter value in the TreeList/List filter system — includes lookup objects */
+type FilterFieldValue = string | number | boolean | Date | null | undefined | {
+    id_public?: string | number;
+    value?: string | number;
+    [key: string]: FilterFieldValue | undefined;
+} | FilterFieldValue[];
+/** Shape of an error object from API/Axios */
+interface ApiErrorLike {
+    code?: string;
+    name?: string;
+    message?: string;
+    status?: number;
+    data?: unknown;
+}
+/** Comparison function for the validation engine */
+type ComparisonFunction = (a: FormDataValue, b: FormDataValue) => boolean;
+/** Named validator function — registered via registerValidator, resolved at validation time. */
+type ValidatorFn = (value: FormDataValue, structure: FormDetailFields) => string;
+interface FormLifecycle<T = FormStoreState> {
+    onBeforeLoad?: (id: string) => void | Promise<void>;
+    onAfterLoad?: (data: FormStoreState) => void;
+    onBeforeSave?: (fields: T) => T;
+    onAfterSave?: (result: FormStoreState) => void;
+}
+
+export { type ApiErrorLike as A, type FormStructureDef as B, type ColumnLayout as C, type DefaultFilter as D, type Indexable as E, type FormDetailRuntime as F, type IndexedFormData as G, type LogicOperator as H, type Identifiable as I, type SystemFilterRecord as J, getField as K, type ListManagerLoadable as L, getIdentifiableId as M, getStoreValue as N, getSubState as O, type Permission as P, isColumnLayout as Q, type ReadOnlyField as R, type SavedLayout as S, isCombinedSettingData as T, isFilterNode as U, type ValidatorFn as V, isFormFieldRuntime as W, isPermission as X, storeBoundary as Y, toFormDataValue as Z, type FormDataValue as a, type FormStoreState as b, type ColumnType as c, type CombinedSettingData as d, type ComparisonFunction as e, type FilterFieldValue as f, type FilterNode as g, type FormChangedPath as h, type FormChangesApi as i, type FormChangesSnapshot as j, type FormCollectionActions as k, type FormCollectionItem as l, type FormDetailFields as m, type FormFieldCore as n, type FormFieldDefinitionRuntime as o, type FormFieldLifecycle as p, type FormFieldMutation as q, type FormFieldRuntime as r, type FormFieldValidation as s, type FormFieldValue as t, type FormFieldVisibility as u, type FormLifecycle as v, type FormManagerBase as w, type FormManagerRef as x, type FormStoreApi as y, type FormStoreInstance as z };