solid-js 2.0.0-experimental.10 → 2.0.0-experimental.12

package/dist/server.js

@@ -1,511 +1 @@
-import { getContext, onCleanup, Owner, runWithOwner, createRoot, setContext, flatten, NotReadyError, getOwner } from '@solidjs/signals';
-export { $PROXY, $TRACK, createRoot, flatten, getOwner, isEqual, isWrappable, onCleanup, runWithOwner } from '@solidjs/signals';
 
-function onMount(fn) {
-  createEffect();
-}
-function createContext(defaultValue, options) {
-  const id = Symbol(options && options.name || "");
-  function provider(props) {
-    return createRoot(() => {
-      setContext(provider, props.value);
-      return children(() => props.children);
-    });
-  }
-  provider.id = id;
-  provider.defaultValue = defaultValue;
-  return provider;
-}
-function useContext(context) {
-  return getContext(context);
-}
-function children(fn) {
-  const children = createMemo(fn);
-  const memo = createMemo(() => flatten(children()));
-  memo.toArray = () => {
-    const c = memo();
-    return Array.isArray(c) ? c : c != null ? [c] : [];
-  };
-  return memo;
-}
-function observable(input) {
-  return {
-    subscribe(observer) {
-      return {
-        unsubscribe() {}
-      };
-    },
-    [Symbol.observable || "@@observable"]() {
-      return this;
-    }
-  };
-}
-function from(producer) {
-  const [s, set] = createSignal(undefined, {
-    equals: false
-  });
-  if ("subscribe" in producer) {
-    const unsub = producer.subscribe(v => set(() => v));
-    onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
-  } else {
-    const clean = producer(set);
-    onCleanup(clean);
-  }
-  return s;
-}
-function ssrRunInScope(fn) {
-  if (Array.isArray(fn)) {
-    const o = new Owner();
-    return fn.map(f => runWithOwner.bind(null, o, f));
-  }
-  return runWithOwner.bind(null, new Owner(), fn);
-}
-
-const ErrorContext = {
-  id: Symbol("ErrorContext"),
-  defaultValue: null
-};
-function ssrHandleError(err) {
-  if (err instanceof NotReadyError) {
-    return err.cause;
-  }
-  const handler = getContext(ErrorContext);
-  if (handler) {
-    handler(err);
-    return;
-  }
-  throw err;
-}
-const sharedConfig = {
-  getNextContextId() {
-    const o = getOwner();
-    if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
-    return o.getNextChildId();
-  }
-};
-function createUniqueId() {
-  return sharedConfig.getNextContextId();
-}
-function createComponent(Comp, props) {
-  return Comp(props || {});
-}
-function For(props) {
-  return createMemo(mapArray(() => props.each, props.children, {
-    fallback: () => props.fallback
-  }));
-}
-function Repeat(props) {
-  return repeat(() => props.count, index => props.children(index), {
-    fallback: () => props.fallback,
-    from: () => props.from
-  });
-}
-function Show(props) {
-  let c;
-  const when = props.when;
-  return when ? typeof (c = props.children) === "function" ? c(() => when) : c : props.fallback || "";
-}
-function Switch(props) {
-  const o = getOwner();
-  const conditions = children(() => props.children);
-  o.getNextChildId();
-  return createMemo(() => {
-    let conds = conditions();
-    Array.isArray(conds) || (conds = [conds]);
-    for (let i = 0; i < conds.length; i++) {
-      const w = conds[i].when;
-      if (w) {
-        const c = conds[i].children;
-        return typeof c === "function" ? c(() => w) : c;
-      }
-    }
-    return props.fallback || "";
-  });
-}
-function Match(props) {
-  return props;
-}
-function ErrorBoundary(props) {
-  const ctx = sharedConfig.context;
-  let sync = true;
-  return createMemo(() => {
-    const o = getOwner();
-    const id = o.id;
-    let res;
-    setContext(ErrorContext, err => {
-      o.dispose(false);
-      ctx.serialize(id, err);
-      runWithOwner(o, () => {
-        const f = props.fallback;
-        res = typeof f === "function" && f.length ? f(err, () => {}) : f;
-        !sync && ctx.replace("e" + id, () => res);
-      });
-    }, o);
-    try {
-      res = flatten(props.children);
-    } catch (err) {
-      ssrHandleError(err);
-    }
-    sync = false;
-    return ctx.ssr([`<!--!$e${id}-->`, `<!--!$/e${id}-->`], ctx.escape(res));
-  });
-}
-function lazy(fn) {
-  let p;
-  let load = id => {
-    if (!p) {
-      p = fn();
-      p.then(mod => {
-        p.v = mod.default;
-      });
-    }
-    return p;
-  };
-  const wrap = props => {
-    sharedConfig.getNextContextId();
-    load();
-    if (p.v) return p.v(props);
-    if (sharedConfig.context.async) {
-      sharedConfig.context.block(p.then(() => {
-        p.s = "success";
-      }));
-    }
-    const err = new NotReadyError();
-    err.cause = p;
-    throw err;
-  };
-  wrap.preload = load;
-  return wrap;
-}
-function enableHydration() {}
-function Suspense(props) {
-  const ctx = sharedConfig.context;
-  const o = new Owner();
-  const id = o.id;
-  o.id += "00";
-  let runPromise;
-  function runInitially() {
-    o.dispose(false);
-    return runWithOwner(o, () => {
-      try {
-        return ctx.resolve(flatten(props.children));
-      } catch (err) {
-        runPromise = ssrHandleError(err);
-      }
-    });
-  }
-  let ret = runInitially();
-  if (!(runPromise || ret.p.length)) return ret;
-  const fallbackOwner = new Owner(id);
-  fallbackOwner.getNextChildId();
-  if (ctx.async) {
-    const done = ctx.registerFragment(id);
-    (async () => {
-      while (runPromise) {
-        await runPromise;
-        runPromise = undefined;
-        ret = runInitially();
-      }
-      while (ret.p.length) {
-        await Promise.all(ret.p);
-        ret = ctx.ssr(ret.t, ...ret.h);
-      }
-      done(ret.t[0]);
-    })();
-    return runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
-  }
-  ctx.serialize(id, "$$f");
-  return runWithOwner(fallbackOwner, () => props.fallback);
-}
-
-class Computation extends Owner {
-  constructor(initialValue, compute) {
-    super();
-    this._value = initialValue;
-    this._compute = compute;
-  }
-  update() {
-    try {
-      this._error = undefined;
-      runWithOwner(this, () => runWithObserver(this, () => this._value = this._compute(this._value)));
-    } catch (err) {
-      this._error = err;
-    }
-  }
-  read() {
-    if (this._error) {
-      throw this._error;
-    }
-    return this._value;
-  }
-}
-let Observer = null;
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const memo = createMemo(p => {
-      let value = first(p ? p[0]() : second);
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(first) : v;
-      }];
-    });
-    return [() => memo()[0](), v => memo()[1](v)];
-  }
-  let o = getOwner();
-  if (o?.id != null) o?.getNextChildId();
-  return [() => first, v => {
-    return first = typeof v === "function" ? v(first) : v;
-  }];
-}
-function createMemo(compute, value, options) {
-  const node = new Computation(value, compute);
-  let v;
-  return () => {
-    if (v !== undefined) return v;
-    node.update();
-    return v = node.read();
-  };
-}
-function createRenderEffect(compute, effect, value, options) {
-  const node = new Computation(value, compute);
-  node.update();
-  try {
-    effect(node.read(), value);
-  } catch (err) {
-  }
-}
-function createEffect(compute, effect, value, options) {
-  let o = getOwner();
-  if (o?.id !== null) o?.getNextChildId();
-}
-function createTrackedEffect(compute, options) {
-  let o = getOwner();
-  if (o?.id !== null) o?.getNextChildId();
-}
-function createReaction(effect, options) {
-  return tracking => {
-    tracking();
-  };
-}
-function createAsync(compute, value, options) {
-  const ctx = sharedConfig.context;
-  const o = new Owner();
-  const id = o.id;
-  let uninitialized = value === undefined;
-  let source;
-  function processSource() {
-    try {
-      source = runWithOwner(o, () => runWithObserver(o, () => compute(value)));
-    } catch (err) {
-      if (err instanceof NotReadyError) {
-        (source = err.cause).then(() => processSource());
-      }
-      return;
-    }
-    const iterator = source[Symbol.asyncIterator];
-    if (source instanceof Promise) {
-      source.then(v => {
-        source.s = "success";
-        return source.value = value = v;
-      });
-      if (ctx.serialize) ctx.serialize(id, source, options?.deferStream);
-      return;
-    } else if (iterator) {
-      source = iterator().next().then(v => {
-        source.s = "success";
-        return source.value = value = v.value;
-      });
-      if (ctx.serialize) ctx.serialize(id, iterator(), options?.deferStream);
-      return;
-    }
-    return () => source;
-  }
-  return processSource() || (() => {
-    if (value === undefined && uninitialized) {
-      const error = new NotReadyError();
-      error.cause = source;
-      throw error;
-    }
-    return value;
-  });
-}
-function isPending(fn, fallback) {
-  try {
-    fn();
-    return false;
-  } catch (err) {
-    if (err instanceof NotReadyError && arguments.length > 1) {
-      return fallback;
-    }
-    throw err;
-  }
-}
-function latest(fn, fallback) {
-  try {
-    return fn();
-  } catch (err) {
-    if (err instanceof NotReadyError && arguments.length > 1) {
-      return fallback;
-    }
-    throw err;
-  }
-}
-function resolve() {
-  throw new Error("resolve is not implemented on the server");
-}
-function flush() {}
-function getObserver() {
-  return Observer;
-}
-function runWithObserver(o, fn) {
-  const prev = Observer;
-  Observer = o;
-  try {
-    return fn();
-  } finally {
-    Observer = prev;
-  }
-}
-function untrack(fn) {
-  return fn();
-}
-function mapArray(list, mapFn, options = {}) {
-  const root = getOwner();
-  const id = root.getNextChildId();
-  return () => {
-    const items = list();
-    let s = [];
-    if (items && items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        const o = new Owner(id + i, true);
-        root.append(o);
-        s.push(runWithOwner(o, () => mapFn(() => items[i], () => i)));
-      }
-    } else if (options.fallback) s = [options.fallback()];
-    return s;
-  };
-}
-function repeat(count, mapFn, options = {}) {
-  const len = count();
-  const offset = options.from?.() || 0;
-  let s = [];
-  if (len) {
-    for (let i = 0; i < len; i++) s.push(mapFn(i + offset));
-  } else if (options.fallback) s = [options.fallback()];
-  return () => s;
-}
-function transition(fn) {
-}
-function useTransition() {
-  return [() => false, () => {}];
-}
-function createOptimistic(value) {
-  return [() => value, v => v];
-}
-
-function isWrappable(obj) {
-  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
-}
-function unwrap(item) {
-  return item;
-}
-function setProperty(state, property, value) {
-  if (state[property] === value) return;
-  if (value === undefined) {
-    delete state[property];
-  } else state[property] = value;
-}
-function createStore(state) {
-  function setStore(fn) {
-    fn(state);
-  }
-  return [state, setStore];
-}
-function createProjection(fn, initialValue = {}) {
-  const [state] = createStore(initialValue);
-  fn(state);
-  return state;
-}
-const createOptimisticStore = createStore;
-function reconcile(value) {
-  return state => {
-    if (!isWrappable(state) || !isWrappable(value)) return value;
-    const targetKeys = Object.keys(value);
-    const previousKeys = Object.keys(state);
-    for (let i = 0, len = targetKeys.length; i < len; i++) {
-      const key = targetKeys[i];
-      setProperty(state, key, value[key]);
-    }
-    for (let i = 0, len = previousKeys.length; i < len; i++) {
-      if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
-    }
-    return state;
-  };
-}
-function merge(...sources) {
-  const target = {};
-  for (let i = 0; i < sources.length; i++) {
-    let source = sources[i];
-    if (typeof source === "function") source = source();
-    if (source) {
-      const descriptors = Object.getOwnPropertyDescriptors(source);
-      for (const key in descriptors) {
-        if (key in target) continue;
-        Object.defineProperty(target, key, {
-          enumerable: true,
-          get() {
-            for (let i = sources.length - 1; i >= 0; i--) {
-              let v,
-                s = sources[i],
-                t = typeof s;
-              if (t === "function") s = s();
-              if (t === "object" && t !== null && key in s) return v;
-            }
-          }
-        });
-      }
-    }
-  }
-  return target;
-}
-function omit(props, ...keys) {
-  const descriptors = Object.getOwnPropertyDescriptors(props),
-    descriptorKeys = Object.keys(descriptors),
-    clone = {};
-  for (let i = 0; i < descriptorKeys.length; i++) {
-    const key = descriptorKeys[i];
-    if (keys.indexOf(key) === -1) {
-      Object.defineProperty(clone, key, descriptors[key]);
-      delete descriptors[key];
-    }
-  }
-  return clone;
-}
-function deep(store) {
-  return store;
-}
-
-function tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(v => [undefined, v], e => {
-        if (e instanceof NotReadyError) throw e;
-        return [e];
-      });
-    }
-    return [undefined, v];
-  } catch (e) {
-    if (e instanceof NotReadyError) throw e;
-    return [e];
-  }
-}
-function reducer(source, reducerFn) {
-  return [source[0], action => {
-    source[1](s => reducerFn(s, action));
-  }];
-}
-
-const $DEVCOMP = Symbol("solid-dev-component");
-const DEV = undefined;
-
-export { $DEVCOMP, DEV, ErrorBoundary, For, Match, Repeat, Show, Suspense, Switch, children, createAsync, createComponent, createContext, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createSignal, createStore, createTrackedEffect, createUniqueId, deep, enableHydration, flush, from, getObserver, isPending, latest, lazy, mapArray, merge, observable, omit, onMount, reconcile, reducer, repeat, resolve, sharedConfig, ssrHandleError, ssrRunInScope, transition, tryCatch, untrack, unwrap, useContext, useTransition };