INIT

node_modules/svelte-toolbelt/dist/utils/merge-props.js

@@ -0,0 +1,126 @@
+/**
+ * Modified from https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/utils/src/mergeProps.ts (see NOTICE.txt for source)
+ */
+import { clsx } from "clsx";
+import { composeHandlers } from "./compose-handlers.js";
+import { cssToStyleObj } from "./css-to-style-obj.js";
+import { isClassValue } from "./is.js";
+import { executeCallbacks } from "./execute-callbacks.js";
+import { styleToString } from "./style.js";
+import { EVENT_LIST_SET } from "./event-list.js";
+function isEventHandler(key) {
+    return EVENT_LIST_SET.has(key);
+}
+/**
+ * Given a list of prop objects, merges them into a single object.
+ * - Automatically composes event handlers (e.g. `onclick`, `oninput`, etc.)
+ * - Chains regular functions with the same name so they are called in order
+ * - Merges class strings with `clsx`
+ * - Merges style objects and converts them to strings
+ * - Handles a bug with Svelte where setting the `hidden` attribute to `false` doesn't remove it
+ * - Overrides other values with the last one
+ */
+export function mergeProps(...args) {
+    const result = { ...args[0] };
+    for (let i = 1; i < args.length; i++) {
+        const props = args[i];
+        if (!props)
+            continue;
+        // Handle string keys
+        for (const key of Object.keys(props)) {
+            const a = result[key];
+            const b = props[key];
+            const aIsFunction = typeof a === "function";
+            const bIsFunction = typeof b === "function";
+            // compose event handlers
+            if (aIsFunction && typeof bIsFunction && isEventHandler(key)) {
+                // handle merging of event handlers
+                const aHandler = a;
+                const bHandler = b;
+                result[key] = composeHandlers(aHandler, bHandler);
+            }
+            else if (aIsFunction && bIsFunction) {
+                // chain non-event handler functions
+                result[key] = executeCallbacks(a, b);
+            }
+            else if (key === "class") {
+                // handle merging acceptable class values from clsx
+                const aIsClassValue = isClassValue(a);
+                const bIsClassValue = isClassValue(b);
+                if (aIsClassValue && bIsClassValue) {
+                    result[key] = clsx(a, b);
+                }
+                else if (aIsClassValue) {
+                    result[key] = clsx(a);
+                }
+                else if (bIsClassValue) {
+                    result[key] = clsx(b);
+                }
+            }
+            else if (key === "style") {
+                const aIsObject = typeof a === "object";
+                const bIsObject = typeof b === "object";
+                const aIsString = typeof a === "string";
+                const bIsString = typeof b === "string";
+                if (aIsObject && bIsObject) {
+                    // both are style objects, merge them
+                    result[key] = { ...a, ...b };
+                }
+                else if (aIsObject && bIsString) {
+                    // a is style object, b is string, convert b to style object and merge
+                    const parsedStyle = cssToStyleObj(b);
+                    result[key] = { ...a, ...parsedStyle };
+                }
+                else if (aIsString && bIsObject) {
+                    // a is string, b is style object, convert a to style object and merge
+                    const parsedStyle = cssToStyleObj(a);
+                    result[key] = { ...parsedStyle, ...b };
+                }
+                else if (aIsString && bIsString) {
+                    // both are strings, convert both to objects and merge
+                    const parsedStyleA = cssToStyleObj(a);
+                    const parsedStyleB = cssToStyleObj(b);
+                    result[key] = { ...parsedStyleA, ...parsedStyleB };
+                }
+                else if (aIsObject) {
+                    result[key] = a;
+                }
+                else if (bIsObject) {
+                    result[key] = b;
+                }
+                else if (aIsString) {
+                    result[key] = a;
+                }
+                else if (bIsString) {
+                    result[key] = b;
+                }
+            }
+            else {
+                // override other values
+                result[key] = b !== undefined ? b : a;
+            }
+        }
+        // handle symbol keys (mostly for `Attachments`)
+        for (const key of Object.getOwnPropertySymbols(props)) {
+            const a = result[key];
+            const b = props[key];
+            // for matching symbols, we just override
+            result[key] = b !== undefined ? b : a;
+        }
+    }
+    // convert style object to string
+    if (typeof result.style === "object") {
+        result.style = styleToString(result.style).replaceAll("\n", " ");
+    }
+    // handle weird svelte bug where `hidden` is not removed when set to `false`
+    if (result.hidden === false) {
+        result.hidden = undefined;
+        delete result.hidden;
+    }
+    // handle weird svelte bug where `disabled` is not removed when set to `false`
+    if (result.disabled === false) {
+        result.disabled = undefined;
+        delete result.disabled;
+    }
+    return result;
+}