{"version":3,"names":["untrack","EVENT_HANDLER_RE","isEventHandlerKey","key","test","composeHandlers","internal","user","event","rest","defaultPrevented","resolveClass","internalV","userV","undefined","isRemovedStyle","value","cssPropertyName","name","startsWith","includes","dashed","replace","letter","toLowerCase","normalizeStyleObject","normalized","declaration","Object","entries","serializeStyleObject","declarations","push","String","join","joinSerializedStyles","left","trim","right","mergeElementStyles","merged","property","internalCss","userCss","resolveStyle","resolveRef","resolveHandler","internalIsFn","userIsFn","resolveAttr","userHas","mergeRootProps","i","u","out","internalKeys","keys","userKeys","userKeySet","Set","seen","define","getter","has","add","defineProperty","enumerable","configurable","get"],"sources":["merge-root-props.ts"],"sourcesContent":["/**\n * `mergeRootProps(internal, user)` — public slot-function prop merger.\n *\n * Distinct from `mergePropsN` (used by ~20 React-port primitives). This\n * one is for the Solid 2.0-native compound surface where a primitive\n * exposes `c.trigger()` / `c.root()` slot functions and the consumer\n * spreads them onto an element with `<Tag {...c.trigger()} />`.\n *\n * Per-key resolution:\n * - `on*` handlers: internal runs first, user runs after unless the\n *   event was `preventDefault()`-ed by internal. `user[k] === undefined`\n *   does NOT clear internal — it's treated as \"absent\". This is the key\n *   difference from Solid's `merge` (RFC 04) and what stops consumers\n *   accidentally killing library behaviour by spreading\n *   `{ onClick: undefined }`.\n * - `class`: returns `[internal.class, user.class]` per RFC 07 — Solid's\n *   class binding handles nested clsx shapes per entry. No string concat.\n * - `style`: object declarations merge with user values winning. Mixed\n *   object/string values serialize deterministically with internal\n *   declarations first and user declarations second.\n * - `ref`: array form `[internal.ref, user.ref]` (skip absent sides;\n *   single value if only one side present). Solid's `applyRef` flattens.\n * - everything else (`data-*`, `aria-*`, plain attrs): user wins when\n *   defined, internal provides the reactive default. `user[k] ===\n *   undefined` means internal wins.\n *\n * Reactivity: getters delegate reads back to `internal[k]` / `user[k]` so\n * source-side getters (e.g. `get \"data-state\"() { return open() ? ... }`)\n * stay live across spreads. The output is a plain object — Solid's\n * compiled spread iterates `Object.keys` once at first spread and binds a\n * render effect per key; each binding then reads through the getter on\n * every relevant flush.\n *\n * Implementation: pre-bake a getter per key in `keys(internal) ∪ keys(user)`\n * at call time. Specialised per which side(s) declared the key — the\n * cheap path (internal-only key) skips per-access branching. Faster than\n * the prior Proxy form (~2.4× by microbench: 123ms → 51ms for 7M reads)\n * and produces an indistinguishable shape for downstream consumers\n * (`Object.keys`, `Object.getOwnPropertyDescriptor`, `in` for known keys\n * all match).\n *\n * Slot prop bags have a static key set at the call site, so pre-baking\n * is correct. Dynamic key sets that grow over time still need `mergePropsN`.\n */\n\nimport { untrack } from \"solid-js\";\nimport type { ElementStyle } from \"./types\";\n\ntype AnyRecord = Record<string | symbol, unknown>;\ntype AnyHandler = (event: Event, ...rest: unknown[]) => unknown;\n\nconst EVENT_HANDLER_RE = /^on[A-Z]/;\n\nfunction isEventHandlerKey(key: string): boolean {\n\treturn EVENT_HANDLER_RE.test(key);\n}\n\nfunction composeHandlers(internal: AnyHandler, user: AnyHandler): AnyHandler {\n\treturn (event: Event, ...rest: unknown[]) => {\n\t\tinternal(event, ...rest);\n\t\tif (event && (event as Event).defaultPrevented) return;\n\t\tuser(event, ...rest);\n\t};\n}\n\n// Lazy resolvers — invoked on every getter access so source-side getters\n// stay reactive. Each resolver re-reads its sides; the per-key getter\n// installed on the output binds these resolvers via closure.\n\nfunction resolveClass(internalV: unknown, userV: unknown): unknown {\n\tif (internalV === undefined) return userV;\n\tif (userV === undefined) return internalV;\n\treturn [internalV, userV];\n}\n\ntype StyleObject = Record<string, string | number>;\n\nfunction isRemovedStyle(value: unknown): value is null | undefined | false {\n\treturn value === undefined || value === null || value === false;\n}\n\nfunction cssPropertyName(name: string): string {\n\tif (name.startsWith(\"--\") || name.includes(\"-\")) return name;\n\tconst dashed = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);\n\treturn /^ms[A-Z]/.test(name) ? `-${dashed}` : dashed;\n}\n\nfunction normalizeStyleObject(value: object): StyleObject {\n\tconst normalized: StyleObject = {};\n\tfor (const [name, declaration] of Object.entries(value)) {\n\t\tif (isRemovedStyle(declaration)) continue;\n\t\tnormalized[cssPropertyName(name)] = declaration as string | number;\n\t}\n\treturn normalized;\n}\n\nfunction serializeStyleObject(value: object): string {\n\tconst declarations: string[] = [];\n\tfor (const [name, declaration] of Object.entries(value)) {\n\t\tif (isRemovedStyle(declaration)) continue;\n\t\tdeclarations.push(`${cssPropertyName(name)}:${String(declaration)}`);\n\t}\n\treturn declarations.join(\";\");\n}\n\nfunction joinSerializedStyles(internal: string, user: string): string {\n\tconst left = internal.trim().replace(/;+$/, \"\");\n\tconst right = user.trim().replace(/^;+/, \"\");\n\tif (!left) return right;\n\tif (!right) return left;\n\treturn `${left};${right}`;\n}\n\n/**\n * Merge two Solid-native style values with the later value taking precedence.\n * Object/object inputs remain objects. If either side is serialized CSS, the\n * result is serialized with internal declarations first and user declarations\n * second, which is deterministic across browser and server rendering.\n */\nexport function mergeElementStyles(\n\tinternal: ElementStyle,\n\tuser: ElementStyle,\n): ElementStyle {\n\tif (isRemovedStyle(internal)) return user;\n\tif (isRemovedStyle(user)) return internal;\n\n\tif (typeof internal !== \"string\" && typeof user !== \"string\") {\n\t\tconst merged = normalizeStyleObject(internal);\n\t\tfor (const [name, declaration] of Object.entries(user)) {\n\t\t\tconst property = cssPropertyName(name);\n\t\t\tif (isRemovedStyle(declaration)) delete merged[property];\n\t\t\telse merged[property] = declaration as string | number;\n\t\t}\n\t\treturn merged;\n\t}\n\n\tconst internalCss =\n\t\ttypeof internal === \"string\" ? internal : serializeStyleObject(internal);\n\tconst userCss = typeof user === \"string\" ? user : serializeStyleObject(user);\n\treturn joinSerializedStyles(internalCss, userCss);\n}\n\nfunction resolveStyle(internalV: unknown, userV: unknown): unknown {\n\treturn mergeElementStyles(internalV as ElementStyle, userV as ElementStyle);\n}\n\nfunction resolveRef(internalV: unknown, userV: unknown): unknown {\n\tif (internalV === undefined) return userV;\n\tif (userV === undefined) return internalV;\n\treturn [internalV, userV];\n}\n\nfunction resolveHandler(internalV: unknown, userV: unknown): unknown {\n\tconst internalIsFn = typeof internalV === \"function\";\n\tconst userIsFn = typeof userV === \"function\";\n\tif (!internalIsFn && !userIsFn) return undefined;\n\tif (!userIsFn) return internalV;\n\tif (!internalIsFn) return userV;\n\treturn composeHandlers(internalV as AnyHandler, userV as AnyHandler);\n}\n\nfunction resolveAttr(\n\tinternalV: unknown,\n\tuserV: unknown,\n\tuserHas: boolean,\n): unknown {\n\tif (userHas && userV !== undefined) return userV;\n\treturn internalV;\n}\n\n/**\n * Accepts any two prop bags and returns the merged bag as a plain\n * `Record<string, unknown>` — which is all every call site needs (each one\n * either assigns the result to a `Record<string, unknown>` or spreads it onto\n * a `dynamic()` element). The widening cast lives HERE, once, instead of forcing every\n * call site to write `internal` just to\n * satisfy a generic whose precise return type nothing consumes.\n */\nexport function mergeRootProps(\n\tinternal: object,\n\tuser?: object,\n): Record<string, unknown> {\n\tconst i = internal as AnyRecord;\n\tconst u = user as AnyRecord | undefined;\n\tconst out = {} as AnyRecord;\n\n\t// Enumerate keys in `untrack`: `Object.keys` on a Solid props proxy fires\n\t// its `ownKeys` trap, which reads the reactive source. The slot key set is\n\t// static at the call site (see the header note), so this read must NOT be\n\t// tracked — otherwise it trips `[STRICT_READ_UNTRACKED]` for every consumer\n\t// (e.g. <PopoverTitle>) and floods the dev console. The per-key getters\n\t// defined below stay fully reactive.\n\tconst internalKeys = untrack(() => Object.keys(i));\n\tconst userKeys = u !== undefined ? untrack(() => Object.keys(u)) : [];\n\t// Membership tests below use this plain Set rather than `key in u`: the\n\t// `in` operator fires the Solid props-proxy's `has` trap, which reads the\n\t// reactive source untracked and trips `[STRICT_READ_UNTRACKED]` (the second\n\t// flood source, alongside the `ownKeys` enumeration above). The key set is\n\t// static at the call site, so a one-shot snapshot is correct.\n\tconst userKeySet = new Set(userKeys);\n\tconst seen = new Set<string>();\n\n\tconst define = (key: string, getter: () => unknown): void => {\n\t\tif (seen.has(key)) return;\n\t\tseen.add(key);\n\t\tObject.defineProperty(out, key, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tget: getter,\n\t\t});\n\t};\n\n\t// Internal-side keys first. Specialise the getter based on whether\n\t// `user` also declares the key, so the cheap path (internal-only) skips\n\t// per-access branching.\n\tfor (const key of internalKeys) {\n\t\tconst userHas = userKeySet.has(key);\n\n\t\tif (key === \"class\") {\n\t\t\tdefine(\n\t\t\t\tkey,\n\t\t\t\tuserHas\n\t\t\t\t\t? () => resolveClass(i[key], (u as AnyRecord)[key])\n\t\t\t\t\t: () => i[key],\n\t\t\t);\n\t\t} else if (key === \"style\") {\n\t\t\tdefine(\n\t\t\t\tkey,\n\t\t\t\tuserHas\n\t\t\t\t\t? () => resolveStyle(i[key], (u as AnyRecord)[key])\n\t\t\t\t\t: () => i[key],\n\t\t\t);\n\t\t} else if (key === \"ref\") {\n\t\t\tdefine(\n\t\t\t\tkey,\n\t\t\t\tuserHas\n\t\t\t\t\t? () => resolveRef(i[key], (u as AnyRecord)[key])\n\t\t\t\t\t: () => i[key],\n\t\t\t);\n\t\t} else if (isEventHandlerKey(key)) {\n\t\t\tdefine(\n\t\t\t\tkey,\n\t\t\t\tuserHas\n\t\t\t\t\t? () => resolveHandler(i[key], (u as AnyRecord)[key])\n\t\t\t\t\t: () => i[key],\n\t\t\t);\n\t\t} else {\n\t\t\tdefine(\n\t\t\t\tkey,\n\t\t\t\tuserHas\n\t\t\t\t\t? () => resolveAttr(i[key], (u as AnyRecord)[key], true)\n\t\t\t\t\t: () => i[key],\n\t\t\t);\n\t\t}\n\t}\n\n\t// User-only keys — specialised but trivial (no internal side to merge).\n\t// Keep a getter (not a data property) so user-side getters stay reactive\n\t// in the same way internal-side getters do.\n\tfor (const key of userKeys) {\n\t\tif (seen.has(key)) continue;\n\t\tdefine(key, () => (u as AnyRecord)[key]);\n\t}\n\n\treturn out as Record<string, unknown>;\n}\n"],"mappings":"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","ignoreList":[]}