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

package/dist/server.cjs

@@ -1,597 +1,2 @@
 'use strict';
 
-var signals = require('@solidjs/signals');
-
-function onMount(fn) {
-  createEffect();
-}
-function createContext(defaultValue, options) {
-  const id = Symbol(options && options.name || "");
-  function provider(props) {
-    return signals.createRoot(() => {
-      signals.setContext(provider, props.value);
-      return children(() => props.children);
-    });
-  }
-  provider.id = id;
-  provider.defaultValue = defaultValue;
-  return provider;
-}
-function useContext(context) {
-  return signals.getContext(context);
-}
-function children(fn) {
-  const children = createMemo(fn);
-  const memo = createMemo(() => signals.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));
-    signals.onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
-  } else {
-    const clean = producer(set);
-    signals.onCleanup(clean);
-  }
-  return s;
-}
-function ssrRunInScope(fn) {
-  if (Array.isArray(fn)) {
-    const o = new signals.Owner();
-    return fn.map(f => signals.runWithOwner.bind(null, o, f));
-  }
-  return signals.runWithOwner.bind(null, new signals.Owner(), fn);
-}
-
-const ErrorContext = {
-  id: Symbol("ErrorContext"),
-  defaultValue: null
-};
-function ssrHandleError(err) {
-  if (err instanceof signals.NotReadyError) {
-    return err.cause;
-  }
-  const handler = signals.getContext(ErrorContext);
-  if (handler) {
-    handler(err);
-    return;
-  }
-  throw err;
-}
-const sharedConfig = {
-  getNextContextId() {
-    const o = signals.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 = signals.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 = signals.getOwner();
-    const id = o.id;
-    let res;
-    signals.setContext(ErrorContext, err => {
-      o.dispose(false);
-      ctx.serialize(id, err);
-      signals.runWithOwner(o, () => {
-        const f = props.fallback;
-        res = typeof f === "function" && f.length ? f(err, () => {}) : f;
-        !sync && ctx.replace("e" + id, () => res);
-      });
-    }, o);
-    try {
-      res = signals.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 signals.NotReadyError();
-    err.cause = p;
-    throw err;
-  };
-  wrap.preload = load;
-  return wrap;
-}
-function enableHydration() {}
-function Suspense(props) {
-  const ctx = sharedConfig.context;
-  const o = new signals.Owner();
-  const id = o.id;
-  o.id += "00";
-  let runPromise;
-  function runInitially() {
-    o.dispose(false);
-    return signals.runWithOwner(o, () => {
-      try {
-        return ctx.resolve(signals.flatten(props.children));
-      } catch (err) {
-        runPromise = ssrHandleError(err);
-      }
-    });
-  }
-  let ret = runInitially();
-  if (!(runPromise || ret.p.length)) return ret;
-  const fallbackOwner = new signals.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 signals.runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
-  }
-  ctx.serialize(id, "$$f");
-  return signals.runWithOwner(fallbackOwner, () => props.fallback);
-}
-
-class Computation extends signals.Owner {
-  constructor(initialValue, compute) {
-    super();
-    this._value = initialValue;
-    this._compute = compute;
-  }
-  update() {
-    try {
-      this._error = undefined;
-      signals.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 = signals.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 = signals.getOwner();
-  if (o?.id !== null) o?.getNextChildId();
-}
-function createTrackedEffect(compute, options) {
-  let o = signals.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 signals.Owner();
-  const id = o.id;
-  let uninitialized = value === undefined;
-  let source;
-  function processSource() {
-    try {
-      source = signals.runWithOwner(o, () => runWithObserver(o, () => compute(value)));
-    } catch (err) {
-      if (err instanceof signals.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 signals.NotReadyError();
-      error.cause = source;
-      throw error;
-    }
-    return value;
-  });
-}
-function isPending(fn, fallback) {
-  try {
-    fn();
-    return false;
-  } catch (err) {
-    if (err instanceof signals.NotReadyError && arguments.length > 1) {
-      return fallback;
-    }
-    throw err;
-  }
-}
-function latest(fn, fallback) {
-  try {
-    return fn();
-  } catch (err) {
-    if (err instanceof signals.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 = signals.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 signals.Owner(id + i, true);
-        root.append(o);
-        s.push(signals.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 signals.NotReadyError) throw e;
-        return [e];
-      });
-    }
-    return [undefined, v];
-  } catch (e) {
-    if (e instanceof signals.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;
-
-Object.defineProperty(exports, "$PROXY", {
-  enumerable: true,
-  get: function () { return signals.$PROXY; }
-});
-Object.defineProperty(exports, "$TRACK", {
-  enumerable: true,
-  get: function () { return signals.$TRACK; }
-});
-Object.defineProperty(exports, "createRoot", {
-  enumerable: true,
-  get: function () { return signals.createRoot; }
-});
-Object.defineProperty(exports, "flatten", {
-  enumerable: true,
-  get: function () { return signals.flatten; }
-});
-Object.defineProperty(exports, "getOwner", {
-  enumerable: true,
-  get: function () { return signals.getOwner; }
-});
-Object.defineProperty(exports, "isEqual", {
-  enumerable: true,
-  get: function () { return signals.isEqual; }
-});
-Object.defineProperty(exports, "isWrappable", {
-  enumerable: true,
-  get: function () { return signals.isWrappable; }
-});
-Object.defineProperty(exports, "onCleanup", {
-  enumerable: true,
-  get: function () { return signals.onCleanup; }
-});
-Object.defineProperty(exports, "runWithOwner", {
-  enumerable: true,
-  get: function () { return signals.runWithOwner; }
-});
-exports.$DEVCOMP = $DEVCOMP;
-exports.DEV = DEV;
-exports.ErrorBoundary = ErrorBoundary;
-exports.For = For;
-exports.Match = Match;
-exports.Repeat = Repeat;
-exports.Show = Show;
-exports.Suspense = Suspense;
-exports.Switch = Switch;
-exports.children = children;
-exports.createAsync = createAsync;
-exports.createComponent = createComponent;
-exports.createContext = createContext;
-exports.createEffect = createEffect;
-exports.createMemo = createMemo;
-exports.createOptimistic = createOptimistic;
-exports.createOptimisticStore = createOptimisticStore;
-exports.createProjection = createProjection;
-exports.createReaction = createReaction;
-exports.createRenderEffect = createRenderEffect;
-exports.createSignal = createSignal;
-exports.createStore = createStore;
-exports.createTrackedEffect = createTrackedEffect;
-exports.createUniqueId = createUniqueId;
-exports.deep = deep;
-exports.enableHydration = enableHydration;
-exports.flush = flush;
-exports.from = from;
-exports.getObserver = getObserver;
-exports.isPending = isPending;
-exports.latest = latest;
-exports.lazy = lazy;
-exports.mapArray = mapArray;
-exports.merge = merge;
-exports.observable = observable;
-exports.omit = omit;
-exports.onMount = onMount;
-exports.reconcile = reconcile;
-exports.reducer = reducer;
-exports.repeat = repeat;
-exports.resolve = resolve;
-exports.sharedConfig = sharedConfig;
-exports.ssrHandleError = ssrHandleError;
-exports.ssrRunInScope = ssrRunInScope;
-exports.transition = transition;
-exports.tryCatch = tryCatch;
-exports.untrack = untrack;
-exports.unwrap = unwrap;
-exports.useContext = useContext;
-exports.useTransition = useTransition;