stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/reset_before_cache_controller.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/declared_value.ts","../../src/controllers/reset_before_cache_controller.ts"],"names":[],"mappings":"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","file":"reset_before_cache_controller.js","sourcesContent":["/**\n * Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n *\n * Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n *\n * Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n */\n\n/**\n * The result of `parse(raw)`, or `fallback` when `parse` throws.\n *\n * Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n */\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n  try {\n    return parse(raw);\n  } catch {\n    return fallback;\n  }\n}\n\n/** What {@link validSelector} needs of the element it probes with. */\nexport interface SelectorProbe {\n  matches(selector: string): boolean;\n}\n\n/**\n * `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n *\n * `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n *\n * The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n */\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n  if (raw.length === 0) return fallback;\n  return parseDeclared(\n    raw,\n    (selector) => {\n      element.matches(selector);\n      return selector;\n    },\n    fallback,\n  );\n}\n\n/** How `compileRegExp` wraps a source before compiling it. */\nexport type RegExpAnchor = \"none\" | \"exact\";\n\n/**\n * `source` compiled as a `RegExp`, or `null` when it does not compile.\n *\n * `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)|(1` becomes `^(?:0)|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n */\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp | null {\n  return parseDeclared(\n    source,\n    (text) => {\n      const bare = new RegExp(text);\n      return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n    },\n    null,\n  );\n}\n\n/**\n * The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n */\nexport function parseJsonObject(raw: string): Record<string, unknown> | null {\n  const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n  if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { validSelector } from \"../utils/declared_value\";\n\n/** Field types whose state is authored markup rather than something a user changed. */\nconst STATELESS_INPUT_TYPES = new Set([\"hidden\", \"submit\", \"reset\", \"button\", \"image\"]);\n\n/**\n * Returns one field to the state its markup declared, discarding what the user\n * changed — the single-field form of a form reset.\n *\n * Assigning `\"\"` would not do this. For a text field it throws away the authored\n * value; for a checkbox, a radio, or a hidden field the `value` IDL attribute\n * writes straight through to the content attribute, so the markup itself is\n * rewritten while the checkedness (the part the user actually moved) is left\n * alone; and for a select it can leave nothing selected at all — a state the page\n * never had.\n */\nfunction restoreField(element: Element): void {\n  if (element instanceof HTMLTextAreaElement) {\n    element.value = element.defaultValue;\n    return;\n  }\n  if (element instanceof HTMLSelectElement) {\n    // An option's declared selectedness is its `selected` content attribute.\n    for (const option of element.options) option.selected = option.hasAttribute(\"selected\");\n    return;\n  }\n  if (element instanceof HTMLInputElement) {\n    if (element.type === \"checkbox\" || element.type === \"radio\") {\n      element.checked = element.defaultChecked;\n    } else if (element.type === \"file\") {\n      // A file field takes no value but the empty one, so assigning its default\n      // back would throw on markup that declared one.\n      element.value = \"\";\n    } else if (!STATELESS_INPUT_TYPES.has(element.type)) {\n      element.value = element.defaultValue;\n    }\n  }\n}\n\n/**\n * Headless **before-cache reset** — Hotwire-specific, with no APG pattern. On `turbo:before-cache` it returns transient UI (open menus/modals,\n * typed-in values, spinning indicators) to its initial state, so a page restored by\n * the Back button is not frozen mid-interaction. Place one on `<body>`.\n *\n * Markup contract (identifier: `stimeo--reset-before-cache`):\n *   <body data-controller=\"stimeo--reset-before-cache\">\n *     <details data-reset-attr=\"open\">…</details>     <!-- remove these attributes -->\n *     <div data-reset-class=\"is-open is-loading\">…</div> <!-- remove these classes -->\n *     <form data-reset-form>…</form>                   <!-- form.reset() -->\n *     <input data-reset-value>                          <!-- back to its authored state -->\n *     <div data-reset-hidden>transient overlay</div>    <!-- re-hide -->\n *     <div data-reset-remove>flash toast</div>          <!-- drop from the DOM -->\n *   </body>\n *\n * `scope` narrows the sweep to the first descendant matching that CSS selector;\n * left empty (the default) it covers the whole element. A selector the engine\n * cannot read falls back to that default rather than taking the sweep down with\n * it, and so does one that matches nothing.\n *\n * `reset` dispatches `{}`; `request` dispatches `{}`.\n *\n * @remarks\n * Behavior only and **idempotent** — every run converges on the same initial state,\n * holding no module-scope state. It does the cross-cutting DOM cleanup directly\n * (attribute removal, class removal, restoring a field to its authored state,\n * re-hiding, node removal) and, when\n * `dispatchReset` is on, fires `stimeo--reset-before-cache:request` so individual\n * Stimeo controllers can run their own close logic. The `turbo:before-cache`\n * listener is paired to `connect()` / `disconnect()` so it never double-registers or\n * leaks. {@link reset} is also a public action for manual triggering.\n */\nexport class ResetBeforeCacheController extends Controller<HTMLElement> {\n  static override values = {\n    scope: { type: String, default: \"\" },\n    dispatchReset: { type: Boolean, default: true },\n  };\n  static actions = [\"reset\"] as const;\n  static events = [\"reset\", \"request\"] as const;\n\n  declare scopeValue: string;\n  declare dispatchResetValue: boolean;\n\n  /** The `scope` declaration after validation; empty when it cannot be parsed. */\n  #scopeSelector = \"\";\n\n  /** Runs the reset just before Turbo caches the snapshot. */\n  readonly #onBeforeCache = (): void => this.reset();\n\n  /**\n   * Validates the scope declaration once, keeping only a selector the engine can\n   * read.\n   *\n   * A selector reads back as an ordinary string, so a malformed one survives\n   * until it is handed to the DOM — and this part runs from a single listener\n   * whose whole job is to keep a cached page from freezing. Falling back to the\n   * default keeps that job running with a visible, findable result instead of\n   * silently taking the sweep down.\n   */\n  scopeValueChanged(): void {\n    this.#scopeSelector = validSelector(this.element, this.scopeValue, \"\");\n  }\n\n  override connect(): void {\n    document.addEventListener(\"turbo:before-cache\", this.#onBeforeCache);\n  }\n\n  override disconnect(): void {\n    document.removeEventListener(\"turbo:before-cache\", this.#onBeforeCache);\n  }\n\n  /**\n   * Resets transient UI within scope to its initial state. Asks controllers to\n   * close (via `request`) first, then applies the declarative `data-reset-*` cleanup,\n   * and finally emits `reset`. Safe to call any number of times (idempotent).\n   *\n   * `dispatchReset` decides only whether the `request` ask goes out; the cleanup\n   * and the closing `reset` run either way. Both the listener and this action\n   * reach the same sweep, so `reset` is emitted for a manual call too.\n   */\n  reset(): void {\n    const root = this.#scopeRoot();\n\n    if (this.dispatchResetValue) this.dispatch(\"request\");\n\n    for (const element of root.querySelectorAll(\"[data-reset-attr]\")) {\n      for (const name of (element.getAttribute(\"data-reset-attr\") ?? \"\").split(/\\s+/)) {\n        if (name) element.removeAttribute(name);\n      }\n    }\n    for (const element of root.querySelectorAll(\"[data-reset-class]\")) {\n      for (const token of (element.getAttribute(\"data-reset-class\") ?? \"\").split(/\\s+/)) {\n        if (token) element.classList.remove(token);\n      }\n    }\n    for (const element of root.querySelectorAll(\"[data-reset-form]\")) {\n      if (element instanceof HTMLFormElement) element.reset();\n    }\n    for (const element of root.querySelectorAll(\"[data-reset-value]\")) {\n      restoreField(element);\n    }\n    for (const element of root.querySelectorAll<HTMLElement>(\"[data-reset-hidden]\")) {\n      element.hidden = true;\n    }\n    // Removal runs last so it cannot drop a node another rule still needed to visit.\n    for (const element of root.querySelectorAll(\"[data-reset-remove]\")) {\n      element.remove();\n    }\n\n    this.dispatch(\"reset\");\n  }\n\n  /** The scan root: a `scope` descendant when set, else the controller element. */\n  #scopeRoot(): Element {\n    if (!this.#scopeSelector) return this.element;\n    return this.element.querySelector(this.#scopeSelector) ?? this.element;\n  }\n}\n"]}