INIT

node_modules/svelte-toolbelt/dist/box/box-extras.svelte.d.ts

@@ -0,0 +1,109 @@
+import type { Getter, MaybeBoxOrGetter } from "../types.js";
+export declare const BoxSymbol: unique symbol;
+export declare const isWritableSymbol: unique symbol;
+export type ReadableBox<T> = {
+    readonly [BoxSymbol]: true;
+    readonly current: T;
+};
+export type WritableBox<T> = ReadableBox<T> & {
+    readonly [isWritableSymbol]: true;
+    current: T;
+};
+/**
+ * Creates a readonly box
+ *
+ * @param getter Function to get the value of the box
+ * @returns A box with a `current` property whose value is the result of the getter.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function boxWith<T>(getter: () => T): ReadableBox<T>;
+/**
+ * Creates a writable box
+ *
+ * @param getter Function to get the value of the box
+ * @param setter Function to set the value of the box
+ * @returns A box with a `current` property which can be set to a new value.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function boxWith<T>(getter: () => T, setter: (v: T) => void): WritableBox<T>;
+/**
+ * @returns Whether the value is a Box
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function isBox(value: unknown): value is ReadableBox<unknown>;
+/**
+ * @returns Whether the value is a WritableBox
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function isWritableBox(value: unknown): value is WritableBox<unknown>;
+/**
+ * Creates a box from either a static value, a box, or a getter function.
+ * Useful when you want to receive any of these types of values and generate a boxed version of it.
+ *
+ * @returns A box with a `current` property whose value.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function boxFrom<T>(value: T | WritableBox<T>): WritableBox<T>;
+declare function boxFrom<T>(value: ReadableBox<T>): ReadableBox<T>;
+declare function boxFrom<T>(value: Getter<T>): ReadableBox<T>;
+declare function boxFrom<T>(value: MaybeBoxOrGetter<T>): ReadableBox<T>;
+declare function boxFrom<T>(value: T): WritableBox<T>;
+type GetKeys<T, U> = {
+    [K in keyof T]: T[K] extends U ? K : never;
+}[keyof T];
+type RemoveValues<T, U> = Omit<T, GetKeys<T, U>>;
+type BoxFlatten<R extends Record<string, unknown>> = Expand<RemoveValues<{
+    [K in keyof R]: R[K] extends WritableBox<infer T> ? T : never;
+}, never> & RemoveValues<{
+    readonly [K in keyof R]: R[K] extends WritableBox<infer _> ? never : R[K] extends ReadableBox<infer T> ? T : never;
+}, never>> & RemoveValues<{
+    [K in keyof R]: R[K] extends ReadableBox<infer _> ? never : R[K];
+}, never>;
+/**
+ * Function that gets an object of boxes, and returns an object of reactive values
+ *
+ * @example
+ * const count = box(0)
+ * const flat = box.flatten({ count, double: box.with(() => count.current) })
+ * // type of flat is { count: number, readonly double: number }
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function boxFlatten<R extends Record<string, unknown>>(boxes: R): BoxFlatten<R>;
+/**
+ * Function that converts a box to a readonly box.
+ *
+ * @example
+ * const count = box(0) // WritableBox<number>
+ * const countReadonly = box.readonly(count) // ReadableBox<number>
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function toReadonlyBox<T>(b: ReadableBox<T>): ReadableBox<T>;
+/**
+ * Creates a writable box.
+ *
+ * @returns A box with a `current` property which can be set to a new value.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function simpleBox<T>(): WritableBox<T | undefined>;
+/**
+ * Creates a writable box with an initial value.
+ *
+ * @param initialValue The initial value of the box.
+ * @returns A box with a `current` property which can be set to a new value.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+declare function simpleBox<T>(initialValue: T): WritableBox<T>;
+export { boxWith, isBox, isWritableBox, boxFrom, boxFlatten, toReadonlyBox, simpleBox };

node_modules/svelte-toolbelt/dist/box/box-extras.svelte.js

@@ -0,0 +1,116 @@
+import { isFunction, isObject } from "../utils/is.js";
+export const BoxSymbol = Symbol("box");
+export const isWritableSymbol = Symbol("is-writable");
+function boxWith(getter, setter) {
+    const derived = $derived.by(getter);
+    if (setter) {
+        return {
+            [BoxSymbol]: true,
+            [isWritableSymbol]: true,
+            get current() {
+                return derived;
+            },
+            set current(v) {
+                setter(v);
+            }
+        };
+    }
+    return {
+        [BoxSymbol]: true,
+        get current() {
+            return getter();
+        }
+    };
+}
+/**
+ * @returns Whether the value is a Box
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+function isBox(value) {
+    return isObject(value) && BoxSymbol in value;
+}
+/**
+ * @returns Whether the value is a WritableBox
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+function isWritableBox(value) {
+    return isBox(value) && isWritableSymbol in value;
+}
+function boxFrom(value) {
+    if (isBox(value))
+        return value;
+    if (isFunction(value))
+        return boxWith(value);
+    return simpleBox(value);
+}
+/**
+ * Function that gets an object of boxes, and returns an object of reactive values
+ *
+ * @example
+ * const count = box(0)
+ * const flat = box.flatten({ count, double: box.with(() => count.current) })
+ * // type of flat is { count: number, readonly double: number }
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+function boxFlatten(boxes) {
+    return Object.entries(boxes).reduce((acc, [key, b]) => {
+        if (!isBox(b)) {
+            return Object.assign(acc, { [key]: b });
+        }
+        if (isWritableBox(b)) {
+            Object.defineProperty(acc, key, {
+                get() {
+                    return b.current;
+                },
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                set(v) {
+                    b.current = v;
+                }
+            });
+        }
+        else {
+            Object.defineProperty(acc, key, {
+                get() {
+                    return b.current;
+                }
+            });
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Function that converts a box to a readonly box.
+ *
+ * @example
+ * const count = box(0) // WritableBox<number>
+ * const countReadonly = box.readonly(count) // ReadableBox<number>
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+function toReadonlyBox(b) {
+    if (!isWritableBox(b))
+        return b;
+    return {
+        [BoxSymbol]: true,
+        get current() {
+            return b.current;
+        }
+    };
+}
+function simpleBox(initialValue) {
+    let current = $state(initialValue);
+    return {
+        [BoxSymbol]: true,
+        [isWritableSymbol]: true,
+        get current() {
+            return current;
+        },
+        set current(v) {
+            current = v;
+        }
+    };
+}
+export { boxWith, isBox, isWritableBox, boxFrom, boxFlatten, toReadonlyBox, simpleBox };

node_modules/svelte-toolbelt/dist/box/box.svelte.d.ts

@@ -0,0 +1,29 @@
+import { boxFrom, boxWith, boxFlatten, toReadonlyBox, type WritableBox } from "./box-extras.svelte.js";
+/**
+ * Creates a writable box.
+ *
+ * @returns A box with a `current` property which can be set to a new value.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+export declare function box<T>(): WritableBox<T | undefined>;
+/**
+ * Creates a writable box with an initial value.
+ *
+ * @param initialValue The initial value of the box.
+ * @returns A box with a `current` property which can be set to a new value.
+ * Useful to pass state to other functions.
+ *
+ * @see {@link https://runed.dev/docs/functions/box}
+ */
+export declare function box<T>(initialValue: T): WritableBox<T>;
+export declare namespace box {
+    export var from: typeof boxFrom;
+    var _a: typeof boxWith;
+    export var flatten: typeof boxFlatten;
+    export var readonly: typeof toReadonlyBox;
+    export var isBox: typeof import("./box-extras.svelte.js").isBox;
+    export var isWritableBox: typeof import("./box-extras.svelte.js").isWritableBox;
+    export { _a as with };
+}

node_modules/svelte-toolbelt/dist/box/box.svelte.js

@@ -0,0 +1,20 @@
+import { boxFrom, boxWith, boxFlatten, toReadonlyBox, isBox, isWritableBox, BoxSymbol, isWritableSymbol } from "./box-extras.svelte.js";
+export function box(initialValue) {
+    let current = $state(initialValue);
+    return {
+        [BoxSymbol]: true,
+        [isWritableSymbol]: true,
+        get current() {
+            return current;
+        },
+        set current(v) {
+            current = v;
+        }
+    };
+}
+box.from = boxFrom;
+box.with = boxWith;
+box.flatten = boxFlatten;
+box.readonly = toReadonlyBox;
+box.isBox = isBox;
+box.isWritableBox = isWritableBox;