@object-ui/plugin-form 17.5.0 → 17.7.0

package/dist/thankYouRedirectCountdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thankYouRedirectCountdown.d.ts","sourceRoot":"","sources":["../src/thankYouRedirectCountdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAM/C;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAmClG"}

package/dist/thankYouRedirectNavigation.d.ts

@@ -0,0 +1,111 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * WHO travels to an ACCEPTED `thankYouPage.redirectUrl` — objectui#5112, the
+ * mount-blindness of `EmbeddableForm`'s thank-you redirect.
+ *
+ * `EmbeddableForm.isRedirectUrlSafe` answers WHETHER a destination may be
+ * followed. This module answers who performs the navigation, and it is a
+ * separate question for the reason objectui#4989 defect 4 established: a rooted
+ * path such as `/thanks` handed to a browser-level navigation resolves against
+ * the ORIGIN root, so under a host mounted at a sub-path (the framework CLI
+ * configures one for every embedded deployment; the console runs at basename
+ * `/_console`) a same-origin in-app destination leaves the application. Only the
+ * host knows its mount, and it offers its mount-aware navigate through
+ * `HostNavigationContext` (`@object-ui/react`, landed by PR #5111).
+ *
+ * ## Why this is a sibling of `submitRedirectNavigation.ts` and not a call into it
+ *
+ * That module serves `submitBehavior.url`, whose accepted set objectstack#7496
+ * ruled **relative-only**: every destination it ever holds is already in-app, so
+ * it hands the seam whatever it was given. This key is deliberately more
+ * permissive — same-origin OR a host in the author's `allowedRedirectHosts`
+ * allowlist — because a public form's thank-you page is often a real external
+ * marketing page. So this key needs an arm the other one does not have, and
+ * putting that arm inside the shared hook would make every `submitBehavior`
+ * consumer carry a branch its contract can never reach. The acceptance set
+ * itself is untouched here (objectui#5112 is explicitly not the card that
+ * revisits it, and objectstack#7496's relative-only rule is NOT imported onto
+ * this key).
+ *
+ * ## The arm split, and the invariant it buys
+ *
+ * - **an app-relative destination** goes through the host's navigate when a
+ *   host supplied one, and falls back to today's browser navigation when none
+ *   was supplied;
+ * - **anything else** — an external destination admitted by the allowlist, and
+ *   equally an ABSOLUTE same-origin URL the author spelled out in full — keeps
+ *   browser-level navigation unconditionally.
+ *
+ * The second arm is not a conservatism, it is the seam's own declared input
+ * contract: `HostNavigationValue.navigate` documents `to` as "an already-resolved,
+ * application-relative path, never an absolute URL: a renderer that holds an
+ * external destination must not launder it through the host's router". A host
+ * navigate is a client-side router transition; an absolute URL is not a path a
+ * router can match, and a cross-origin one is not the router's to attempt at
+ * all. So the discriminant is the seam's admission rule restated as a predicate
+ * on the string, which yields the invariant worth stating out loud and pinning:
+ * **the host seam can never be handed a cross-origin URL**, because a relative
+ * reference cannot carry an authority (RFC 3986) and therefore always resolves
+ * to the base's origin.
+ *
+ * An absolute same-origin URL landing in the browser arm is a deliberate call,
+ * not an oversight. It is the one destination shape the card's two named arms do
+ * not cover, and routing it through the seam would mean this package rewriting
+ * `https://forms.example/thanks` into `/thanks` for a router that would then
+ * place it at `/_console/thanks` — a DIFFERENT address from the one the author
+ * wrote. An author who spelled the whole address asked for that address; the
+ * mount-blindness this card fixes is the one where the author wrote no origin at
+ * all and had no way to express the mount.
+ *
+ * ## Absent seam is not a degraded mode
+ *
+ * With no provider the behaviour is byte-for-byte what it was: one
+ * `window.location.href` assignment of the authored destination after the
+ * declared delay. A host with no router has no basename, so origin-rooted
+ * resolution is already correct there.
+ */
+/**
+ * An accepted thank-you destination plus the delay declared with it, captured at
+ * the moment the write was accepted (objectui#5049) — see the state's own
+ * comment in `EmbeddableForm`.
+ */
+export interface PendingThankYouRedirect {
+    url: string;
+    delayMs: number;
+}
+/**
+ * Is `rawUrl` an application-relative reference — i.e. a destination the host's
+ * router can be asked to place?
+ *
+ * True for `/thanks`, `thanks`, `?ok=1`, `#done`. False for `https://x/y`,
+ * `//x/y` (protocol-relative carries an authority), `javascript:…`, and for a
+ * same-origin ABSOLUTE URL — see the module docblock for why that last one is
+ * deliberate.
+ *
+ * The question is answered by the URL parser rather than by a hand-written
+ * scheme grammar, so leading whitespace and C0 controls are handled exactly the
+ * way the parser handles them and there is no second spelling of RFC 3986 in
+ * this repo to drift from the first.
+ *
+ * This predicate does NOT judge whether a destination may be followed —
+ * `isRedirectUrlSafe` already did that, and this runs only on values it
+ * accepted. It picks who travels, nothing more.
+ */
+export declare function isAppRelativeDestination(rawUrl: string): boolean;
+/**
+ * Own the delayed leg of an accepted thank-you redirect: wait the declared
+ * `delayMs`, then travel to `pending.url` through the host's navigate if one was
+ * injected AND the destination is app-relative, else through
+ * `window.location.href`.
+ *
+ * Unmounting, or dropping the destination, cancels the wait — the property
+ * objectui#5049 bought, preserved here unchanged: this hook is the effect
+ * `EmbeddableForm` used to declare inline, with the seam added and nothing else
+ * moved.
+ *
+ * Pass `null` when nothing is pending.
+ */
+export declare function useThankYouRedirectNavigation(pending: PendingThankYouRedirect | null): void;
+//# sourceMappingURL=thankYouRedirectNavigation.d.ts.map

package/dist/thankYouRedirectNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thankYouRedirectNavigation.d.ts","sourceRoot":"","sources":["../src/thankYouRedirectNavigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAKH;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAYhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,GAAG,IAAI,CA+B3F"}

package/dist/uploadGate.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { useUploadingScope } from '@object-ui/fields';
+export interface UploadGate {
+    /** True while at least one upload inside this form is still in flight. */
+    uploading: boolean;
+    /** Mount around the form body so its upload widgets report in. */
+    scope: ReturnType<typeof useUploadingScope>;
+    /** The Save button's label while `uploading`. */
+    busyLabel: string;
+    /** Why Save is unavailable — shown, and used as the refusal message. */
+    reason: string;
+}
+/**
+ * Own the gate for one record form. The host renders its form body inside
+ * {@link UploadGateProvider} with the returned `scope`.
+ */
+export declare function useUploadGate(): UploadGate;
+/** Re-exported under this package's own name so hosts import one module. */
+export declare function UploadGateProvider({ gate, children, }: {
+    gate: UploadGate;
+    children: React.ReactNode;
+}): React.ReactElement;
+/**
+ * The visible reason. Rendered beside the action row, not as a toast: the
+ * explanation has to be readable at the moment the user looks at the control
+ * that will not respond, and a toast is gone by then.
+ *
+ * `role="status"` (polite) rather than `alert`: nothing has gone wrong, an
+ * upload is simply still running, and an assertive live region would interrupt
+ * a screen-reader user mid-sentence every time a file is picked.
+ */
+export declare function UploadInFlightNotice({ gate }: {
+    gate: UploadGate;
+}): React.ReactElement | null;
+//# sourceMappingURL=uploadGate.d.ts.map

package/dist/uploadGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadGate.d.ts","sourceRoot":"","sources":["../src/uploadGate.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,iBAAiB,EAA0B,MAAM,mBAAmB,CAAC;AAgD9E,MAAM,WAAW,UAAU;IACzB,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,KAAK,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5C,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAS1C;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,GAAG,KAAK,CAAC,YAAY,CAErB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CAO9F"}

package/dist/writePayload.d.ts

@@ -0,0 +1,68 @@
+import { LoadedRecordSnapshot } from './sanitize.js';
+import { FieldWriteGate } from './fieldWriteGate.js';
+/** The facts of a form schema the outbound sequence reads. */
+export interface FormWriteTarget {
+    mode?: string;
+    objectName: string;
+    recordId?: string | number | null;
+    /** Inline field definitions (`object-form.customFields`). */
+    customFields?: readonly unknown[] | null;
+}
+/** Where the outbound sequence gets its answers from. */
+export interface FormWriteSources {
+    /** The object definition the form loaded, or `null` when it has none. */
+    objectSchema: {
+        fields?: Record<string, Record<string, unknown> | undefined>;
+    } | null | undefined;
+    /** The caller's field-level write verdict — {@link FieldWriteGate}. */
+    canEdit: FieldWriteGate | undefined;
+    /** The record this form read for the record it edits (objectui#10156). */
+    snapshot: LoadedRecordSnapshot | null | undefined;
+}
+export interface FormWritePayloads {
+    /**
+     * Every value the form may write, as the form now holds it: stripped of what
+     * a form never writes and, on a create, of the fields the producer owns.
+     */
+    payload: Record<string, unknown>;
+    /**
+     * What the save sends — on BOTH routes, the host `submitHandler` and the
+     * form's own create / OCC-guarded update. On an edit, the fields of
+     * {@link FormWritePayloads.payload} that differ from the record the form
+     * read; otherwise `payload` itself.
+     */
+    writePayload: Record<string, unknown>;
+}
+/**
+ * The ONE outbound sequence of a record form: what a save writes, built from
+ * the values the form collected (objectui#10563).
+ *
+ * 1. `sanitizeFormData` drops what a form never writes — server-owned columns
+ *    (objectui#10108), computed / formula / read-only columns, keys the object
+ *    does not declare, and every field the caller's field-level security
+ *    refuses (`canEdit`, `80c54122e`).
+ * 2. On a create, `omitServerResolvedDefaults` drops an empty field whose
+ *    runtime default the producer resolves (#4069).
+ * 3. On an edit, `dirtyEditPayload` keeps only the fields that differ from the
+ *    record the form read (objectui#10156), and sends the whole of step 1's
+ *    result when it cannot settle that.
+ *
+ * ## Why it is one function
+ *
+ * `ObjectForm` routes a record save through several layouts, and each layout
+ * owns its save handler. When the sequence was spelled inline in each handler,
+ * three of them — `TabbedForm`, `SplitForm` and `WizardForm` (which also renders
+ * a simple form's mobile `stepper`) — carried none of it and wrote every value
+ * they held, `id`, `owner_id`, the formula columns and the field-level-refused
+ * ones included. ⛔ Do not spell any step of it beside a call to this function.
+ *
+ * ## The inline-members rule
+ *
+ * With a non-empty `customFields` the object definition is NOT handed to steps
+ * 1 and 2: an inline member may name a field the object never declares (it is
+ * appended after the generated set, objectui#9778), and the unknown-key strip
+ * would drop the value the author asked for. The server-owned roster and the
+ * field-level verdict still apply, because neither needs a definition.
+ */
+export declare function formWritePayload(values: Record<string, unknown>, form: FormWriteTarget, { objectSchema, canEdit, snapshot }: FormWriteSources): FormWritePayloads;
+//# sourceMappingURL=writePayload.d.ts.map

package/dist/writePayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writePayload.d.ts","sourceRoot":"","sources":["../src/writePayload.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,6DAA6D;IAC7D,YAAY,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,CAAC;CAC1C;AAED,yDAAyD;AACzD,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,YAAY,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAClG,uEAAuE;IACvE,OAAO,EAAE,cAAc,GAAG,SAAS,CAAC;IACpC,0EAA0E;IAC1E,QAAQ,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC;CACnD;AAED,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,eAAe,EACrB,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,gBAAgB,GACpD,iBAAiB,CAanB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/plugin-form",
-  "version": "17.5.0",
+  "version": "17.7.0",
   "type": "module",
   "license": "MIT",
   "description": "Form plugin for Object UI",
@@ -15,15 +15,15 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^17.0.0-rc.6",
-    "lucide-react": "^1.29.0",
-    "@object-ui/components": "17.5.0",
-    "@object-ui/core": "17.5.0",
-    "@object-ui/fields": "17.5.0",
-    "@object-ui/i18n": "17.5.0",
-    "@object-ui/permissions": "17.5.0",
-    "@object-ui/react": "17.5.0",
-    "@object-ui/types": "17.5.0"
+    "@objectstack/spec": "^17.0.0",
+    "lucide-react": "^1.43.0",
+    "@object-ui/components": "17.7.0",
+    "@object-ui/core": "17.7.0",
+    "@object-ui/fields": "17.7.0",
+    "@object-ui/i18n": "17.7.0",
+    "@object-ui/permissions": "17.7.0",
+    "@object-ui/react": "17.7.0",
+    "@object-ui/types": "17.7.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
@@ -35,7 +35,8 @@
     "typescript": "^6.0.3",
     "vite": "^8.2.1",
     "vite-plugin-dts": "^5.0.3",
-    "@object-ui/data-objectstack": "17.5.0"
+    "@object-ui/data-objectstack": "17.7.0",
+    "@object-ui/test-support": "17.4.0"
   },
   "keywords": [
     "objectui",
@@ -71,7 +72,7 @@
   ],
   "scripts": {
     "build": "vite build",
-    "test": "vitest run",
+    "test": "vitest run --root ../.. packages/plugin-form/",
     "type-check": "tsc --noEmit && tsc -p tsconfig.test.json",
     "lint": "eslint ."
   }