phlex-reactive 0.4.8 → 0.9.0

data/app/javascript/phlex/reactive/compute.min.js

@@ -0,0 +1,4 @@
+var j=new Map;function q(b,p){j.set(b,p)}function v(b){return j.get(b)}function w(){j.clear()}export{q as setComputeReducer,v as computeReducer,w as __resetComputeRegistryForTest};
+
+//# debugId=5EACBA6D0928063864756E2164756E21
+//# sourceMappingURL=compute.min.js.map

data/app/javascript/phlex/reactive/compute.min.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["compute.js"],
+  "sourcesContent": [
+    "// The client-side compute (data-binding) registry — the \"instant\" half of the\n// new/unpersisted-record UX.\n//\n// A record-backed reactive component round-trips every change to the server\n// (the signed identity re-finds the record; the server re-renders). A NEW,\n// unpersisted record has no such server truth to re-render against on every\n// keystroke — the classic answer is a bespoke Stimulus controller doing the math\n// in the browser (carlqvist's new_order_controller.js). This registry lets that\n// math be a DECLARED part of the component instead: `reactive_compute :name,\n// inputs:, outputs:` (Ruby) names a reducer registered here, and the generic\n// reactive controller runs it on `input` — writing the outputs with NO round\n// trip. When the component ALSO carries on(...) (a persisted record, or a draft\n// you sync), the debounced POST reconciles from the authoritative server reply.\n//\n// The seam mirrors confirm.js: a settable registry with a lookup the controller\n// calls. Register once at boot:\n//\n//   import { setComputeReducer } from \"phlex/reactive/compute\"\n//   setComputeReducer(\"payment_split\", ({ allowance, cash, leasing, total }) => ({\n//     allowance, leasing, cash: total - allowance - leasing,\n//   }))\n//\n// The reducer's signature is (values, meta):\n//\n//   values — a plain object of { inputName: value } over the declared inputs.\n//            Untyped inputs (the array form) AND :number-typed inputs arrive as\n//            Numbers (blank/NaN → 0); :string-typed inputs (the hash form,\n//            issue #104) arrive as the RAW string. `reactive_compute :x, inputs:\n//            { title: :string, qty: :number }` is what selects per-input types;\n//            `inputs: %i[a b]` stays all-numeric (backward compatible).\n//   meta   — { changed }: the name (string) of the declared input the\n//            triggering event edited, or null (a direct recompute() call, or a\n//            target this root doesn't own / didn't declare as an input).\n//\n// OUTPUTS may be a form FIELD or a TEXT NODE (issue #104). An output whose name\n// matches an owned control writes its .value (+ the change-guarded input\n// dispatch below). An output with NO matching field writes textContent to every\n// owned [data-reactive-text=\"<name>\"] node (reactive_text(:name)) — XSS-safe by\n// construction, change-guarded, NO input dispatch (a text node has no listener\n// contract). A declared INPUT also mirrors into its own text node on every\n// input via an always-run pass — so reactive_text(:title) is a live field\n// preview with NO registered reducer at all.\n//\n// It returns a plain object of { outputName: value } — only the outputs it\n// names are written, so it can leave the edited field (and its caret)\n// untouched. A one-argument reducer keeps working unchanged (it just ignores\n// meta). `changed` is what makes a MULTI-WAY / MUTUAL rebalance expressible as\n// one reducer (issue #75) — branch on which field the user edited:\n//\n//   setComputeReducer(\"three_way_split\", ({ field_a, field_b, field_c, total }, { changed }) => {\n//     if (changed === \"field_c\") return { field_a: total - field_c - field_b }\n//     return { field_c: total - field_a - field_b }\n//   })\n//\n// Output writes are CHANGE-GUARDED: the controller writes a field and\n// dispatches a bubbling `input` event on it ONLY when the new value differs\n// from the field's current value (real browsers never fire `input` on a\n// programmatic .value write, so the controller dispatches explicitly — that's\n// what drives a chained summary repaint, matching the server's set_value +\n// dispatch(\"input\") contract). Returning the SAME value a field already holds\n// is skipped entirely — no write, no event — which is why a reducer with\n// overlapping inputs/outputs (like payment_split above) settles instead of\n// re-entering itself forever.\n//\n// CONVERGENCE REQUIREMENT: because an output write dispatches a REAL input\n// event (issue #76), recompute re-enters with changed = that OUTPUT field's\n// name (when it's also a declared input). A branching reducer must therefore\n// be convergent: the re-entrant pass must compute values EQUAL to what the\n// first pass already wrote to the DOM, so the change guard settles the chain.\n// The three_way_split above is: after `changed === \"field_a\"` writes field_c,\n// the re-entrant `changed === \"field_c\"` pass derives field_a back to the\n// value it already holds — no write, no event, settled in one bounce.\n\nconst reducers = new Map()\n\n// Register (or replace) the reducer for `key`. `fn` is\n// (values: Record<string, number>, meta: { changed: string | null })\n//   => Record<string, unknown>.\nexport function setComputeReducer(key, fn) {\n  reducers.set(key, fn)\n}\n\n// Look up a registered reducer; undefined when none — the controller then makes\n// #recompute a no-op rather than throwing (a missing reducer must not break the\n// page; it just means no client-side binding for that root).\nexport function computeReducer(key) {\n  return reducers.get(key)\n}\n\n// Test seam: clear the registry so a reducer registered in one test can't leak.\nexport function __resetComputeRegistryForTest() {\n  reducers.clear()\n}\n"
+  ],
+  "mappings": "AAyEA,IAAM,EAAW,IAAI,IAKd,SAAS,CAAiB,CAAC,EAAK,EAAI,CACzC,EAAS,IAAI,EAAK,CAAE,EAMf,SAAS,CAAc,CAAC,EAAK,CAClC,OAAO,EAAS,IAAI,CAAG,EAIlB,SAAS,CAA6B,EAAG,CAC9C,EAAS,MAAM",
+  "debugId": "5EACBA6D0928063864756E2164756E21",
+  "names": []
+}

data/app/javascript/phlex/reactive/confirm.min.js

@@ -0,0 +1,4 @@
+var k=(b)=>Promise.resolve(typeof window<"u"?window.confirm(b):!0);function p(b){k=b}export{p as setConfirmResolver,k as confirmResolver};
+
+//# debugId=95D50A0903B9B05E64756E2164756E21
+//# sourceMappingURL=confirm.min.js.map

data/app/javascript/phlex/reactive/confirm.min.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["confirm.js"],
+  "sourcesContent": [
+    "// The overridable confirmation resolver behind `on(:action, confirm: \"…\")`\n// (issue #55, follow-up to #52).\n//\n// The reactive controller preempts the click event (its own preventDefault +\n// POST), so Hotwire's `data-turbo-confirm` — which routes through\n// `Turbo.config.forms.confirm` — never runs for a reactive trigger. That made\n// the reactive path the ONE interaction a Hotwire app couldn't theme: every\n// confirmable reactive action showed the unstyled native window.confirm chrome.\n//\n// This module is the seam. `dispatch` resolves the confirm message through\n// `confirmResolver`, which defaults to a Promise-wrapped window.confirm (so the\n// 0.4.5 behavior is byte-for-byte unchanged when nothing is configured: sync,\n// no dependency, screen-reader friendly). An app reuses its themed dialog with\n// one line at boot:\n//\n//   import { setConfirmResolver } from \"phlex/reactive/confirm\"\n//   setConfirmResolver((message) => window.Turbo.config.forms.confirm(message))\n//\n// The resolver may be sync or async — the controller awaits it via\n// Promise.resolve, so a bare boolean and a Promise<boolean> both work. It must\n// resolve truthy to proceed; a falsy resolve (or a rejection) cancels the\n// action — exactly like declining the native prompt.\n\n// The default: wrap the synchronous native confirm in a Promise so the call\n// site can always `await` it. Read window lazily (per call), not at module load\n// — under SSR / test the global may not exist yet when this module is imported.\nexport let confirmResolver = (message) =>\n  Promise.resolve(typeof window !== \"undefined\" ? window.confirm(message) : true)\n\n// Override the resolver. Pass a function `(message) => boolean | Promise<boolean>`.\n// Truthy resolves the action through; falsy (or a rejected Promise) cancels it.\nexport function setConfirmResolver(fn) {\n  confirmResolver = fn\n}\n"
+  ],
+  "mappings": "AA0BO,IAAI,EAAkB,CAAC,IAC5B,QAAQ,QAAQ,OAAO,OAAW,IAAc,OAAO,QAAQ,CAAO,EAAI,EAAI,EAIzE,SAAS,CAAkB,CAAC,EAAI,CACrC,EAAkB",
+  "debugId": "95D50A0903B9B05E64756E2164756E21",
+  "names": []
+}