solid-js 1.9.11 → 2.0.0-beta.0

package/store/dist/store.js

@@ -1,429 +0,0 @@
-import { $PROXY, $TRACK, getListener, batch, createSignal } from 'solid-js';
-
-const $RAW = Symbol("store-raw"),
-  $NODE = Symbol("store-node"),
-  $HAS = Symbol("store-has"),
-  $SELF = Symbol("store-self");
-function wrap$1(value) {
-  let p = value[$PROXY];
-  if (!p) {
-    Object.defineProperty(value, $PROXY, {
-      value: p = new Proxy(value, proxyTraps$1)
-    });
-    if (!Array.isArray(value)) {
-      const keys = Object.keys(value),
-        desc = Object.getOwnPropertyDescriptors(value);
-      for (let i = 0, l = keys.length; i < l; i++) {
-        const prop = keys[i];
-        if (desc[prop].get) {
-          Object.defineProperty(value, prop, {
-            enumerable: desc[prop].enumerable,
-            get: desc[prop].get.bind(p)
-          });
-        }
-      }
-    }
-  }
-  return p;
-}
-function isWrappable(obj) {
-  let proto;
-  return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
-}
-function unwrap(item, set = new Set()) {
-  let result, unwrapped, v, prop;
-  if (result = item != null && item[$RAW]) return result;
-  if (!isWrappable(item) || set.has(item)) return item;
-  if (Array.isArray(item)) {
-    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
-    for (let i = 0, l = item.length; i < l; i++) {
-      v = item[i];
-      if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
-    }
-  } else {
-    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
-    const keys = Object.keys(item),
-      desc = Object.getOwnPropertyDescriptors(item);
-    for (let i = 0, l = keys.length; i < l; i++) {
-      prop = keys[i];
-      if (desc[prop].get) continue;
-      v = item[prop];
-      if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
-    }
-  }
-  return item;
-}
-function getNodes(target, symbol) {
-  let nodes = target[symbol];
-  if (!nodes) Object.defineProperty(target, symbol, {
-    value: nodes = Object.create(null)
-  });
-  return nodes;
-}
-function getNode(nodes, property, value) {
-  if (nodes[property]) return nodes[property];
-  const [s, set] = createSignal(value, {
-    equals: false,
-    internal: true
-  });
-  s.$ = set;
-  return nodes[property] = s;
-}
-function proxyDescriptor$1(target, property) {
-  const desc = Reflect.getOwnPropertyDescriptor(target, property);
-  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
-  delete desc.value;
-  delete desc.writable;
-  desc.get = () => target[$PROXY][property];
-  return desc;
-}
-function trackSelf(target) {
-  getListener() && getNode(getNodes(target, $NODE), $SELF)();
-}
-function ownKeys(target) {
-  trackSelf(target);
-  return Reflect.ownKeys(target);
-}
-const proxyTraps$1 = {
-  get(target, property, receiver) {
-    if (property === $RAW) return target;
-    if (property === $PROXY) return receiver;
-    if (property === $TRACK) {
-      trackSelf(target);
-      return receiver;
-    }
-    const nodes = getNodes(target, $NODE);
-    const tracked = nodes[property];
-    let value = tracked ? tracked() : target[property];
-    if (property === $NODE || property === $HAS || property === "__proto__") return value;
-    if (!tracked) {
-      const desc = Object.getOwnPropertyDescriptor(target, property);
-      if (getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
-    }
-    return isWrappable(value) ? wrap$1(value) : value;
-  },
-  has(target, property) {
-    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
-    getListener() && getNode(getNodes(target, $HAS), property)();
-    return property in target;
-  },
-  set() {
-    return true;
-  },
-  deleteProperty() {
-    return true;
-  },
-  ownKeys: ownKeys,
-  getOwnPropertyDescriptor: proxyDescriptor$1
-};
-function setProperty(state, property, value, deleting = false) {
-  if (!deleting && state[property] === value) return;
-  const prev = state[property],
-    len = state.length;
-  if (value === undefined) {
-    delete state[property];
-    if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
-  } else {
-    state[property] = value;
-    if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
-  }
-  let nodes = getNodes(state, $NODE),
-    node;
-  if (node = getNode(nodes, property, prev)) node.$(() => value);
-  if (Array.isArray(state) && state.length !== len) {
-    for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
-    (node = getNode(nodes, "length", len)) && node.$(state.length);
-  }
-  (node = nodes[$SELF]) && node.$();
-}
-function mergeStoreNode(state, value) {
-  const keys = Object.keys(value);
-  for (let i = 0; i < keys.length; i += 1) {
-    const key = keys[i];
-    setProperty(state, key, value[key]);
-  }
-}
-function updateArray(current, next) {
-  if (typeof next === "function") next = next(current);
-  next = unwrap(next);
-  if (Array.isArray(next)) {
-    if (current === next) return;
-    let i = 0,
-      len = next.length;
-    for (; i < len; i++) {
-      const value = next[i];
-      if (current[i] !== value) setProperty(current, i, value);
-    }
-    setProperty(current, "length", len);
-  } else mergeStoreNode(current, next);
-}
-function updatePath(current, path, traversed = []) {
-  let part,
-    prev = current;
-  if (path.length > 1) {
-    part = path.shift();
-    const partType = typeof part,
-      isArray = Array.isArray(current);
-    if (Array.isArray(part)) {
-      for (let i = 0; i < part.length; i++) {
-        updatePath(current, [part[i]].concat(path), traversed);
-      }
-      return;
-    } else if (isArray && partType === "function") {
-      for (let i = 0; i < current.length; i++) {
-        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
-      }
-      return;
-    } else if (isArray && partType === "object") {
-      const {
-        from = 0,
-        to = current.length - 1,
-        by = 1
-      } = part;
-      for (let i = from; i <= to; i += by) {
-        updatePath(current, [i].concat(path), traversed);
-      }
-      return;
-    } else if (path.length > 1) {
-      updatePath(current[part], path, [part].concat(traversed));
-      return;
-    }
-    prev = current[part];
-    traversed = [part].concat(traversed);
-  }
-  let value = path[0];
-  if (typeof value === "function") {
-    value = value(prev, traversed);
-    if (value === prev) return;
-  }
-  if (part === undefined && value == undefined) return;
-  value = unwrap(value);
-  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
-    mergeStoreNode(prev, value);
-  } else setProperty(current, part, value);
-}
-function createStore(...[store, options]) {
-  const unwrappedStore = unwrap(store || {});
-  const isArray = Array.isArray(unwrappedStore);
-  const wrappedStore = wrap$1(unwrappedStore);
-  function setStore(...args) {
-    batch(() => {
-      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
-    });
-  }
-  return [wrappedStore, setStore];
-}
-
-function proxyDescriptor(target, property) {
-  const desc = Reflect.getOwnPropertyDescriptor(target, property);
-  if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
-  delete desc.value;
-  delete desc.writable;
-  desc.get = () => target[$PROXY][property];
-  desc.set = v => target[$PROXY][property] = v;
-  return desc;
-}
-const proxyTraps = {
-  get(target, property, receiver) {
-    if (property === $RAW) return target;
-    if (property === $PROXY) return receiver;
-    if (property === $TRACK) {
-      trackSelf(target);
-      return receiver;
-    }
-    const nodes = getNodes(target, $NODE);
-    const tracked = nodes[property];
-    let value = tracked ? tracked() : target[property];
-    if (property === $NODE || property === $HAS || property === "__proto__") return value;
-    if (!tracked) {
-      const desc = Object.getOwnPropertyDescriptor(target, property);
-      const isFunction = typeof value === "function";
-      if (getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
-        return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
-      }
-    }
-    return isWrappable(value) ? wrap(value) : value;
-  },
-  has(target, property) {
-    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
-    getListener() && getNode(getNodes(target, $HAS), property)();
-    return property in target;
-  },
-  set(target, property, value) {
-    batch(() => setProperty(target, property, unwrap(value)));
-    return true;
-  },
-  deleteProperty(target, property) {
-    batch(() => setProperty(target, property, undefined, true));
-    return true;
-  },
-  ownKeys: ownKeys,
-  getOwnPropertyDescriptor: proxyDescriptor
-};
-function wrap(value) {
-  let p = value[$PROXY];
-  if (!p) {
-    Object.defineProperty(value, $PROXY, {
-      value: p = new Proxy(value, proxyTraps)
-    });
-    const keys = Object.keys(value),
-      desc = Object.getOwnPropertyDescriptors(value);
-    const proto = Object.getPrototypeOf(value);
-    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
-    if (isClass) {
-      let curProto = proto;
-      while (curProto != null) {
-        const descriptors = Object.getOwnPropertyDescriptors(curProto);
-        keys.push(...Object.keys(descriptors));
-        Object.assign(desc, descriptors);
-        curProto = Object.getPrototypeOf(curProto);
-      }
-    }
-    for (let i = 0, l = keys.length; i < l; i++) {
-      const prop = keys[i];
-      if (isClass && prop === "constructor") continue;
-      if (desc[prop].get) {
-        const get = desc[prop].get.bind(p);
-        Object.defineProperty(value, prop, {
-          get,
-          configurable: true
-        });
-      }
-      if (desc[prop].set) {
-        const og = desc[prop].set,
-          set = v => batch(() => og.call(p, v));
-        Object.defineProperty(value, prop, {
-          set,
-          configurable: true
-        });
-      }
-    }
-  }
-  return p;
-}
-function createMutable(state, options) {
-  const unwrappedStore = unwrap(state || {});
-  const wrappedStore = wrap(unwrappedStore);
-  return wrappedStore;
-}
-function modifyMutable(state, modifier) {
-  batch(() => modifier(unwrap(state)));
-}
-
-const $ROOT = Symbol("store-root");
-function applyState(target, parent, property, merge, key) {
-  const previous = parent[property];
-  if (target === previous) return;
-  const isArray = Array.isArray(target);
-  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
-    setProperty(parent, property, target);
-    return;
-  }
-  if (isArray) {
-    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
-      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
-        applyState(target[start], previous, start, merge, key);
-      }
-      const temp = new Array(target.length),
-        newIndices = new Map();
-      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
-        temp[newEnd] = previous[end];
-      }
-      if (start > newEnd || start > end) {
-        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
-        for (; j < target.length; j++) {
-          setProperty(previous, j, temp[j]);
-          applyState(target[j], previous, j, merge, key);
-        }
-        if (previous.length > target.length) setProperty(previous, "length", target.length);
-        return;
-      }
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = target[j];
-        keyVal = key && item ? item[key] : item;
-        i = newIndices.get(keyVal);
-        newIndicesNext[j] = i === undefined ? -1 : i;
-        newIndices.set(keyVal, j);
-      }
-      for (i = start; i <= end; i++) {
-        item = previous[i];
-        keyVal = key && item ? item[key] : item;
-        j = newIndices.get(keyVal);
-        if (j !== undefined && j !== -1) {
-          temp[j] = previous[i];
-          j = newIndicesNext[j];
-          newIndices.set(keyVal, j);
-        }
-      }
-      for (j = start; j < target.length; j++) {
-        if (j in temp) {
-          setProperty(previous, j, temp[j]);
-          applyState(target[j], previous, j, merge, key);
-        } else setProperty(previous, j, target[j]);
-      }
-    } else {
-      for (let i = 0, len = target.length; i < len; i++) {
-        applyState(target[i], previous, i, merge, key);
-      }
-    }
-    if (previous.length > target.length) setProperty(previous, "length", target.length);
-    return;
-  }
-  const targetKeys = Object.keys(target);
-  for (let i = 0, len = targetKeys.length; i < len; i++) {
-    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
-  }
-  const previousKeys = Object.keys(previous);
-  for (let i = 0, len = previousKeys.length; i < len; i++) {
-    if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
-  }
-}
-function reconcile(value, options = {}) {
-  const {
-      merge,
-      key = "id"
-    } = options,
-    v = unwrap(value);
-  return state => {
-    if (!isWrappable(state) || !isWrappable(v)) return v;
-    const res = applyState(v, {
-      [$ROOT]: state
-    }, $ROOT, merge, key);
-    return res === undefined ? state : res;
-  };
-}
-const producers = new WeakMap();
-const setterTraps = {
-  get(target, property) {
-    if (property === $RAW) return target;
-    const value = target[property];
-    let proxy;
-    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
-  },
-  set(target, property, value) {
-    setProperty(target, property, unwrap(value));
-    return true;
-  },
-  deleteProperty(target, property) {
-    setProperty(target, property, undefined, true);
-    return true;
-  }
-};
-function produce(fn) {
-  return state => {
-    if (isWrappable(state)) {
-      let proxy;
-      if (!(proxy = producers.get(state))) {
-        producers.set(state, proxy = new Proxy(state, setterTraps));
-      }
-      fn(proxy);
-    }
-    return state;
-  };
-}
-
-const DEV = undefined;
-
-export { $RAW, DEV, createMutable, createStore, modifyMutable, produce, reconcile, unwrap };

package/store/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "solid-js/store",
-  "main": "./dist/server.cjs",
-  "module": "./dist/server.js",
-  "unpkg": "./dist/store.cjs",
-  "types": "./types/index.d.ts",
-  "type": "module",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "worker": {
-        "types": "./types/index.d.ts",
-        "import": "./dist/server.js",
-        "require": "./dist/server.cjs"
-      },
-      "browser": {
-        "development": {
-          "types": "./types/index.d.ts",
-          "import": "./dist/dev.js",
-          "require": "./dist/dev.cjs"
-        },
-        "types": "./types/index.d.ts",
-        "import": "./dist/store.js",
-        "require": "./dist/store.cjs"
-      },
-      "deno": {
-        "types": "./types/index.d.ts",
-        "import": "./dist/server.js",
-        "require": "./dist/server.cjs"
-      },
-      "node": {
-        "types": "./types/index.d.ts",
-        "import": "./dist/server.js",
-        "require": "./dist/server.cjs"
-      },
-      "development": {
-        "types": "./types/index.d.ts",
-        "import": "./dist/dev.js",
-        "require": "./dist/dev.cjs"
-      },
-      "types": "./types/index.d.ts",
-      "import": "./dist/store.js",
-      "require": "./dist/store.cjs"
-    }
-  }
-}

package/store/types/index.d.ts

@@ -1,12 +0,0 @@
-export { $RAW, createStore, unwrap } from "./store.js";
-export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
-export * from "./mutable.js";
-export * from "./modifiers.js";
-import { $NODE, isWrappable } from "./store.js";
-export declare const DEV: {
-    readonly $NODE: typeof $NODE;
-    readonly isWrappable: typeof isWrappable;
-    readonly hooks: {
-        onStoreNodeUpdate: import("./store.js").OnStoreNodeUpdate | null;
-    };
-} | undefined;

package/store/types/modifiers.d.ts

@@ -1,6 +0,0 @@
-export type ReconcileOptions = {
-    key?: string | null;
-    merge?: boolean;
-};
-export declare function reconcile<T extends U, U>(value: T, options?: ReconcileOptions): (state: U) => T;
-export declare function produce<T>(fn: (state: T) => void): (state: T) => T;

package/store/types/mutable.d.ts

@@ -1,5 +0,0 @@
-import { StoreNode } from "./store.js";
-export declare function createMutable<T extends StoreNode>(state: T, options?: {
-    name?: string;
-}): T;
-export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;

package/store/types/server.d.ts

@@ -1,17 +0,0 @@
-import type { SetStoreFunction, Store } from "./store.js";
-export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
-export declare const $RAW: unique symbol;
-export declare function isWrappable(obj: any): boolean;
-export declare function unwrap<T>(item: T): T;
-export declare function setProperty(state: any, property: PropertyKey, value: any, force?: boolean): void;
-export declare function updatePath(current: any, path: any[], traversed?: PropertyKey[]): void;
-export declare function createStore<T>(state: T | Store<T>): [Store<T>, SetStoreFunction<T>];
-export declare function createMutable<T>(state: T | Store<T>): T;
-export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;
-type ReconcileOptions = {
-    key?: string | null;
-    merge?: boolean;
-};
-export declare function reconcile<T extends U, U extends object>(value: T, options?: ReconcileOptions): (state: U) => T;
-export declare function produce<T>(fn: (state: T) => void): (state: T) => T;
-export declare const DEV: undefined;

package/store/types/store.d.ts

@@ -1,107 +0,0 @@
-export declare const IS_DEV: string | boolean;
-export declare const $RAW: unique symbol, $NODE: unique symbol, $HAS: unique symbol, $SELF: unique symbol;
-export declare const DevHooks: {
-    onStoreNodeUpdate: OnStoreNodeUpdate | null;
-};
-type DataNode = {
-    (): any;
-    $(value?: any): void;
-};
-export type DataNodes = Record<PropertyKey, DataNode | undefined>;
-export type OnStoreNodeUpdate = (state: StoreNode, property: PropertyKey, value: StoreNode | NotWrappable, prev: StoreNode | NotWrappable) => void;
-export interface StoreNode {
-    [$NODE]?: DataNodes;
-    [key: PropertyKey]: any;
-}
-export declare namespace SolidStore {
-    interface Unwrappable {
-    }
-}
-export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-export type Store<T> = T;
-export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
-/**
- * Returns the underlying data in the store without a proxy.
- * @param item store proxy object
- * @example
- * ```js
- * const initial = {z...};
- * const [state, setState] = createStore(initial);
- * initial === state; // => false
- * initial === unwrap(state); // => true
- * ```
- */
-export declare function unwrap<T>(item: T, set?: Set<unknown>): T;
-export declare function getNodes(target: StoreNode, symbol: typeof $NODE | typeof $HAS): DataNodes;
-export declare function getNode(nodes: DataNodes, property: PropertyKey, value?: any): DataNode;
-export declare function proxyDescriptor(target: StoreNode, property: PropertyKey): TypedPropertyDescriptor<any> | undefined;
-export declare function trackSelf(target: StoreNode): void;
-export declare function ownKeys(target: StoreNode): (string | symbol)[];
-export declare function setProperty(state: StoreNode, property: PropertyKey, value: any, deleting?: boolean): void;
-export declare function updatePath(current: StoreNode, path: any[], traversed?: PropertyKey[]): void;
-/** @deprecated */
-export type DeepReadonly<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
-    readonly [K in keyof T]: DeepReadonly<T[K]>;
-};
-/** @deprecated */
-export type DeepMutable<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
-    -readonly [K in keyof T]: DeepMutable<T[K]>;
-};
-export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
-    [K in Extract<keyof T, `${number}`>]?: T[K];
-} : {
-    [x: number]: T[number];
-} : Partial<T>;
-export type PickMutable<T> = {
-    [K in keyof T as (<U>() => U extends {
-        [V in K]: T[V];
-    } ? 1 : 2) extends <U>() => U extends {
-        -readonly [V in K]: T[V];
-    } ? 1 : 2 ? K : never]: T[K];
-};
-export type StorePathRange = {
-    from?: number;
-    to?: number;
-    by?: number;
-};
-export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
-export type StoreSetter<T, U extends PropertyKey[] = []> = T | CustomPartial<T> | ((prevState: T, traversed: U) => T | CustomPartial<T>);
-export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
-type W<T> = Exclude<T, NotWrappable>;
-type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [
-    T
-] extends [readonly unknown[]] ? number : keyof T : keyof T;
-type MutableKeyOf<T> = KeyOf<T> & keyof PickMutable<T>;
-type Rest<T, U extends PropertyKey[], K extends KeyOf<T> = KeyOf<T>> = [T] extends [never] ? never : K extends MutableKeyOf<T> ? [Part<T, K>, ...RestSetterOrContinue<T[K], [K, ...U]>] : K extends KeyOf<T> ? [Part<T, K>, ...RestContinue<T[K], [K, ...U]>] : never;
-type RestContinue<T, U extends PropertyKey[]> = 0 extends 1 & T ? [...Part<any>[], StoreSetter<any, PropertyKey[]>] : Rest<W<T>, U>;
-type RestSetterOrContinue<T, U extends PropertyKey[]> = [StoreSetter<T, U>] | RestContinue<T, U>;
-export interface SetStoreFunction<T> {
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends MutableKeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: StoreSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [
-        K7,
-        K6,
-        K5,
-        K4,
-        K3,
-        K2,
-        K1
-    ]>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends MutableKeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: StoreSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6], [K6, K5, K4, K3, K2, K1]>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends MutableKeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: StoreSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5], [K5, K4, K3, K2, K1]>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends MutableKeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: StoreSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4], [K4, K3, K2, K1]>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends MutableKeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: StoreSetter<W<W<W<T>[K1]>[K2]>[K3], [K3, K2, K1]>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends MutableKeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: StoreSetter<W<W<T>[K1]>[K2], [K2, K1]>): void;
-    <K1 extends MutableKeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: StoreSetter<W<T>[K1], [K1]>): void;
-    (setter: StoreSetter<T, []>): void;
-    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, ...rest: Rest<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [K7, K6, K5, K4, K3, K2, K1]>): void;
-}
-/**
- * Creates a reactive store that can be read through a proxy object and written with a setter function
- *
- * @description https://docs.solidjs.com/reference/store-utilities/create-store
- */
-export declare function createStore<T extends object = {}>(...[store, options]: {} extends T ? [store?: T | Store<T>, options?: {
-    name?: string;
-}] : [store: T | Store<T>, options?: {
-    name?: string;
-}]): [get: Store<T>, set: SetStoreFunction<T>];
-export {};

package/types/reactive/array.d.ts

@@ -1,44 +0,0 @@
-import { Accessor } from "./signal.js";
-/**
-The MIT License (MIT)
-
-Copyright (c) 2017 Adam Haile
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-/**
- * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
- *
- * similar to `Array.prototype.map`, but gets the index as accessor, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
- */
-export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
-    fallback?: Accessor<any>;
-}): () => U[];
-/**
- * Reactively maps arrays by index instead of value - underlying helper for the `<Index>` control flow
- *
- * similar to `Array.prototype.map`, but gets the value as an accessor, transforms only changed items of the original arrays anew and returns an accessor.
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/index-array
- */
-export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
-    fallback?: Accessor<any>;
-}): () => U[];