@memberjunction/ng-base-forms 5.37.0 → 5.39.0

package/dist/lib/interactive-form/interactive-form.component.d.ts

@@ -0,0 +1,181 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { BaseEntity } from '@memberjunction/core';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+import { FormHostProps } from '@memberjunction/interactive-component-types/forms';
+import { MJReactComponent, ReactComponentEvent } from '@memberjunction/ng-react';
+import { BaseFormComponent } from '../base-form-component';
+import * as i0 from "@angular/core";
+/**
+ * Wraps a Component (the IC kind — declared `componentRole: 'form'`) so it can
+ * stand in for an Angular form on any entity.
+ *
+ * **Layering invariant:** the React component never touches BaseEntity. This
+ * wrapper owns the entity lifecycle (`record.Save`, `record.Delete`, mode
+ * transitions). The React component sees only the snapshot in
+ * {@link FormHostProps} and communicates back via `BeforeSave` /
+ * `BeforeDelete` / `EditModeChangeRequested` events plus its dirty-field diff.
+ *
+ * Instantiated by `SingleRecordComponent.LoadForm` when the resolver finds an
+ * `EntityFormOverride` matching the user's scope. Behaves exactly like the
+ * generated Angular form from the host's perspective: same `record` setter,
+ * same `EditMode` toggle, same outputs.
+ */
+export declare class InteractiveFormComponent extends BaseFormComponent implements OnInit, OnDestroy {
+    /**
+     * The bound record. Backed by a setter so swapping records *after*
+     * the component has mounted (e.g. Form Builder cockpit preview record
+     * picker) triggers a fresh `originalSnapshot` capture + a
+     * `formHostProps` rebuild — without this, the React form keeps
+     * rendering the original record's values even after the input
+     * changes. Guarded on `_recordInitialized` so the post-mount path
+     * doesn't fire during the first input assignment (handled by
+     * `ngOnInit`, which sets both `originalSnapshot` and `formHostProps`).
+     */
+    private _record;
+    private _recordInitialized;
+    set record(value: BaseEntity);
+    get record(): BaseEntity;
+    /**
+     * The Component row ID resolved for this (entity, user, roles) tuple. Set
+     * by `SingleRecordComponent.LoadForm` after the resolver returns an
+     * override.
+     */
+    ComponentID: string | null;
+    /**
+     * Loaded ComponentSpec, parsed from the Component row's `Specification` JSON.
+     *
+     * Two ways to populate this:
+     *   1. **Via `ComponentID`** (the standard path): set the input, ngOnInit
+     *      fetches the row from `MJ: Components` and assigns the parsed spec.
+     *   2. **Direct assignment** (the artifact-viewer path): the caller already
+     *      has the spec in hand (parsed from an artifact JSON blob) and sets
+     *      `componentSpec` directly. In that case `ComponentID` should be left
+     *      null and the DB fetch is skipped.
+     */
+    componentSpec: ComponentSpec | null;
+    /**
+     * When true, render the React component **without** the
+     * `<mj-record-form-container>` wrapper — i.e. no toolbar (no Save /
+     * Cancel / Edit / Delete / History / Tags / Lists).
+     *
+     * Used by the Form Builder cockpit's Preview tab where the toolbar's
+     * actions don't apply (Save would save the *record*, but the cockpit's
+     * own Save button saves the *spec*; History/Tags assume a real
+     * persistent record, but the preview record can be a synthetic
+     * NewRecord). Keeping just the form body produces a clean "this is
+     * what the form looks like" view.
+     */
+    previewMode: boolean;
+    /** FormHostProps passed to the React component. Recomputed when record or mode changes. */
+    formHostProps: FormHostProps | null;
+    /** Loaded-spec error (component row missing, JSON parse failure, etc.). */
+    private _loadError;
+    /**
+     * Loaded-spec error (component row missing, JSON parse failure,
+     * React-runtime bootstrap failure, etc.). Setter auto-emits
+     * `LoadErrorChanged` so host surfaces (e.g. Form Builder cockpit
+     * Preview tab) can show their own error state — retrospective fix #10.
+     */
+    get loadError(): string | null;
+    set loadError(v: string | null);
+    LoadErrorChanged: EventEmitter<string | null>;
+    /** Tracks last-known field snapshot for computing the dirty-field diff on save. */
+    private originalSnapshot;
+    /**
+     * Reference to the mounted React component. Used by the SaveRecord /
+     * CancelEdit overrides below to invoke the component's registered
+     * `RequestSave` / `RequestCancel` methods when the host toolbar fires
+     * Save/Cancel — so the single user-visible Save lives on the toolbar
+     * (consistent with every other entity form in MJ) and not duplicated
+     * inside the form body.
+     */
+    reactComponent?: MJReactComponent;
+    /**
+     * Promise resolver populated when `SaveRecord` invokes `RequestSave`
+     * on the React component. `handleBeforeSave` resolves it after the
+     * BeforeSave-driven entity save completes, so SaveRecord can return
+     * a meaningful success boolean and honor `StopEditModeAfterSave`.
+     */
+    private pendingSaveResolver;
+    private readonly changeDetector;
+    private readonly reactBridge;
+    ngOnInit(): Promise<void>;
+    /**
+     * Called by the React component via `mj-react-component`'s `componentEvent`
+     * @Output. Maps the form-role event names to BaseEntity operations.
+     */
+    OnReactComponentEvent(event: ReactComponentEvent): Promise<void>;
+    /**
+     * Apply the React component's dirty-field diff to the BaseEntity, save,
+     * and refresh the snapshot. Errors surface via `LatestResult.CompleteMessage`
+     * per the BaseEntity Save contract.
+     *
+     * Resolves `pendingSaveResolver` if {@link SaveRecord} initiated this
+     * flow via the toolbar — so the toolbar can return a meaningful boolean
+     * and honor `StopEditModeAfterSave`.
+     */
+    private handleBeforeSave;
+    private resolvePendingSave;
+    private handleBeforeDelete;
+    private handleEditModeChangeRequested;
+    /**
+     * Propagate Angular-toolbar-driven mode changes into the React component's
+     * `FormHostProps.mode`. Without these overrides, clicking Edit on the
+     * `<mj-record-form-container>` toolbar flips `this.EditMode` but the React
+     * side still sees `mode: 'view'`.
+     */
+    StartEditMode(): void;
+    EndEditMode(): void;
+    /**
+     * Toolbar **Save** override. Routes the click through the React
+     * component's registered `RequestSave` method so the React layer can
+     * (a) run its own validation, (b) flush its draft state, (c) emit
+     * `BeforeSave` with the dirty-field diff — exactly the flow the
+     * in-form Save button would trigger. The wrapper then awaits the
+     * BeforeSave handler via `pendingSaveResolver`, gets a real
+     * success/failure boolean, and honors `StopEditModeAfterSave`.
+     *
+     * Falls back to the base implementation for components that haven't
+     * registered `RequestSave` — preserves correctness for forms that
+     * keep their own in-form Save button (older sample, hand-authored
+     * forms that pre-date this contract).
+     */
+    SaveRecord(StopEditModeAfterSave: boolean): Promise<boolean>;
+    /**
+     * Toolbar **Cancel** override. Asks the React component to discard
+     * its draft via `RequestCancel`, then flips out of edit mode the
+     * same way the base implementation would. The React component is
+     * expected to (a) clear its local draft state and (b) emit
+     * `EditModeChangeRequested({ requestedMode: 'view' })` — though we
+     * call `EndEditMode` here directly anyway, so even a no-op handler
+     * leaves the form in a coherent state.
+     */
+    CancelEdit(): void;
+    /**
+     * Resolve the Component row, parse its `Specification`, and surface either
+     * the spec or an error. Backed by `InteractiveFormsEngine` (in-memory
+     * cache, BaseEntity event-driven invalidation) so this is a sub-ms JS
+     * lookup once the engine has loaded — the engine handles freshness
+     * via remote-invalidate events, replacing the prior RunView's
+     * `BypassCache: true` escape hatch. Falls through to a one-shot
+     * RunView only on engine-cache miss (defensive — the engine should
+     * always have a Type='Form' Component, but if a brand-new Component
+     * was just created on the server and the invalidation event hasn't
+     * propagated yet, we still want to render rather than blank-screen).
+     */
+    private loadComponentSpec;
+    /**
+     * Build `FormHostProps` from the current record + permissions + edit mode.
+     * Called whenever the record loads, mode changes, or save completes.
+     */
+    private rebuildFormHostProps;
+    private primaryKeyToPlain;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveFormComponent, "mj-interactive-form", never, { "record": { "alias": "record"; "required": false; }; "ComponentID": { "alias": "ComponentID"; "required": false; }; "componentSpec": { "alias": "componentSpec"; "required": false; }; "previewMode": { "alias": "previewMode"; "required": false; }; }, { "LoadErrorChanged": "LoadErrorChanged"; }, never, never, false, never>;
+}
+/**
+ * Tree-shaking guard. Imported and called from public-api.ts so bundlers don't
+ * drop the component when no consumer references it by name.
+ */
+export declare function LoadInteractiveFormComponent(): void;
+//# sourceMappingURL=interactive-form.component.d.ts.map

package/dist/lib/interactive-form/interactive-form.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-form.component.d.ts","sourceRoot":"","sources":["../../../src/lib/interactive-form/interactive-form.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,YAAY,EAAS,SAAS,EAAE,MAAM,EAA6B,MAAM,eAAe,CAAC;AAChI,OAAO,EAAE,UAAU,EAAmC,MAAM,sBAAsB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAC5E,OAAO,EACH,aAAa,EAOhB,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAsB,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACrG,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;;AAE3D;;;;;;;;;;;;;;GAcG;AACH,qBAKa,wBAAyB,SAAQ,iBAAkB,YAAW,MAAM,EAAE,SAAS;IAExF;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,kBAAkB,CAAS;IAEnC,IACoB,MAAM,CAAC,KAAK,EAAE,UAAU,EAQ3C;IACD,IAAoB,MAAM,IAAI,UAAU,CAAyB;IAEjE;;;;OAIG;IACa,WAAW,EAAE,MAAM,GAAG,IAAI,CAAQ;IAElD;;;;;;;;;;OAUG;IACa,aAAa,EAAE,aAAa,GAAG,IAAI,CAAQ;IAE3D;;;;;;;;;;;OAWG;IACa,WAAW,UAAS;IAEpC,2FAA2F;IACpF,aAAa,EAAE,aAAa,GAAG,IAAI,CAAQ;IAElD,2EAA2E;IAC3E,OAAO,CAAC,UAAU,CAAuB;IAEzC;;;;;OAKG;IACH,IAAW,SAAS,IAAI,MAAM,GAAG,IAAI,CAA4B;IACjE,IAAW,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAIpC;IAEgB,gBAAgB,8BAAqC;IAEtE,mFAAmF;IACnF,OAAO,CAAC,gBAAgB,CAA+B;IAEvD;;;;;;;OAOG;IACiC,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAEtE;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAA6C;IAExE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAEpC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B/C;;;OAGG;IACU,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB7E;;;;;;;;OAQG;YACW,gBAAgB;IAgD9B,OAAO,CAAC,kBAAkB;YAOZ,kBAAkB;IAahC,OAAO,CAAC,6BAA6B;IAWrC;;;;;OAKG;IACa,aAAa,IAAI,IAAI;IAKrB,WAAW,IAAI,IAAI;IAKnC;;;;;;;;;;;;;OAaG;IACmB,UAAU,CAAC,qBAAqB,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlF;;;;;;;;OAQG;IACa,UAAU,IAAI,IAAI;IAiBlC;;;;;;;;;;;OAWG;YACW,iBAAiB;IAoE/B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA6B5B,OAAO,CAAC,iBAAiB;yCAnbhB,wBAAwB;2CAAxB,wBAAwB;CA0bpC;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAMnD"}