solid-js 2.0.0-experimental.13 → 2.0.0-experimental.14

package/dist/server.js

@@ -1 +1,442 @@
+import { getOwner, getNextChildId, createOwner, runWithOwner, isWrappable, NotReadyError, setContext, getContext, createRoot, flatten } from '@solidjs/signals';
+export { $PROXY, $TRACK, NotReadyError, createRoot, flatten, getOwner, isEqual, isWrappable, merge, omit, onCleanup, runWithOwner, snapshot } from '@solidjs/signals';
 
+const sharedConfig = {
+  getNextContextId() {
+    const o = getOwner();
+    if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    return getNextChildId(o);
+  }
+};
+
+let Observer = null;
+function runWithObserver(comp, fn) {
+  const prev = Observer;
+  Observer = comp;
+  try {
+    return fn();
+  } finally {
+    Observer = prev;
+  }
+}
+function getObserver() {
+  return Observer;
+}
+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(value) : v;
+      }];
+    });
+    return [() => memo()[0](), v => memo()[1](v)];
+  }
+  return [() => first, v => {
+    return first = typeof v === "function" ? v(first) : v;
+  }];
+}
+function createMemo(compute, value, options) {
+  const ctx = sharedConfig.context;
+  const owner = createOwner();
+  const comp = {
+    owner,
+    value: value,
+    compute: compute,
+    error: undefined,
+    computed: false
+  };
+  function update() {
+    try {
+      comp.error = undefined;
+      const result = runWithOwner(owner, () => runWithObserver(comp, () => comp.compute(comp.value)));
+      comp.computed = true;
+      processResult(comp, result, owner, ctx);
+    } catch (err) {
+      if (err instanceof NotReadyError) {
+        err.source?.then(() => update());
+      }
+      comp.error = err;
+      comp.computed = true;
+    }
+  }
+  if (!options?.lazy) {
+    update();
+  }
+  return () => {
+    if (!comp.computed) {
+      update();
+    }
+    if (comp.error) {
+      throw comp.error;
+    }
+    return comp.value;
+  };
+}
+function processResult(comp, result, owner, ctx) {
+  const id = owner.id;
+  const uninitialized = comp.value === undefined;
+  if (result instanceof Promise) {
+    result.then(v => {
+      result.s = 1;
+      result.v = comp.value = v;
+      comp.error = undefined;
+    });
+    if (ctx?.serialize && id) ctx.serialize(id, result);
+    if (uninitialized) {
+      comp.error = new NotReadyError(result);
+    }
+    return;
+  }
+  const iterator = result?.[Symbol.asyncIterator];
+  if (typeof iterator === "function") {
+    const iter = iterator.call(result);
+    const promise = iter.next().then(v => {
+      promise.s = 1;
+      promise.v = comp.value = v.value;
+      comp.error = undefined;
+    });
+    if (ctx?.serialize && id) ctx.serialize(id, promise);
+    if (uninitialized) {
+      comp.error = new NotReadyError(promise);
+    }
+    return;
+  }
+  comp.value = result;
+}
+function createEffect(compute, effect, value, options) {
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
+}
+function createRenderEffect(compute, effectFn, value, options) {
+  const owner = createOwner();
+  try {
+    const result = runWithOwner(owner, () => runWithObserver({
+      owner,
+      value: value,
+      compute: compute,
+      error: undefined,
+      computed: true
+    }, () => compute(value)));
+    effectFn(result, value);
+  } catch (err) {
+  }
+}
+function createTrackedEffect(compute, options) {
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
+}
+function createReaction(effectFn, options) {
+  return tracking => {
+    tracking();
+  };
+}
+function createOptimistic(first, second, third) {
+  return createSignal(first, second);
+}
+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];
+}
+const createOptimisticStore = createStore;
+function createProjection(fn, initialValue = {}) {
+  const [state] = createStore(initialValue);
+  fn(state);
+  return state;
+}
+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 deep(store) {
+  return store;
+}
+function mapArray(list, mapFn, options = {}) {
+  const root = getOwner();
+  const id = getNextChildId(root);
+  return () => {
+    const items = list();
+    let s = [];
+    if (items && items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        const o = createOwner({
+          id: id + i
+        });
+        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;
+}
+const ErrorContext = {
+  id: Symbol("ErrorContext"),
+  defaultValue: null
+};
+function createErrorBoundary(fn, fallback) {
+  const owner = createOwner();
+  return runWithOwner(owner, () => {
+    let result;
+    setContext(ErrorContext, err => {
+      result = fallback(err, () => {});
+    });
+    try {
+      result = fn();
+    } catch (err) {
+      result = fallback(err, () => {});
+    }
+    return () => result;
+  });
+}
+function createLoadBoundary(fn, fallback) {
+  try {
+    const result = fn();
+    return () => result;
+  } catch (err) {
+    if (err instanceof NotReadyError) {
+      return () => fallback();
+    }
+    throw err;
+  }
+}
+function untrack(fn) {
+  return fn();
+}
+function flush() {}
+function resolve(fn) {
+  throw new Error("resolve is not implemented on the server");
+}
+function isPending(fn, fallback) {
+  try {
+    fn();
+    return false;
+  } catch (err) {
+    if (err instanceof NotReadyError && arguments.length > 1) {
+      return fallback;
+    }
+    throw err;
+  }
+}
+function pending(fn) {
+  return fn();
+}
+function isRefreshing() {
+  return false;
+}
+function refresh(fn) {
+  return fn();
+}
+function action(fn) {
+  return fn;
+}
+function onSettled(callback) {
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
+}
+
+const $DEVCOMP = Symbol("solid-dev-component");
+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 childrenMemo = createMemo(fn);
+  const memo = createMemo(() => flatten(childrenMemo()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function ssrRunInScope(fn) {
+  if (Array.isArray(fn)) {
+    const o = createOwner();
+    return fn.map(f => runWithOwner.bind(null, o, f));
+  }
+  return runWithOwner.bind(null, createOwner(), fn);
+}
+
+function enableHydration() {}
+function createComponent(Comp, props) {
+  return Comp(props || {});
+}
+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";
+      }));
+    }
+    throw new NotReadyError(p);
+  };
+  wrap.preload = load;
+  return wrap;
+}
+function createUniqueId() {
+  return sharedConfig.getNextContextId();
+}
+
+function For(props) {
+  const options = "fallback" in props ? {
+    keyed: props.keyed,
+    fallback: () => props.fallback
+  } : {
+    keyed: props.keyed
+  };
+  return createMemo(mapArray(() => props.each, props.children, options));
+}
+function Repeat(props) {
+  const options = "fallback" in props ? {
+    fallback: () => props.fallback
+  } : {};
+  options.from = () => props.from;
+  return repeat(() => props.count, index => typeof props.children === "function" ? props.children(index) : props.children, options);
+}
+function Show(props) {
+  const when = props.when;
+  if (when) {
+    const child = props.children;
+    if (typeof child === "function" && child.length > 0) {
+      return child(() => when);
+    }
+    return child;
+  }
+  return props.fallback;
+}
+function Switch(props) {
+  const chs = children(() => props.children);
+  const o = getOwner();
+  if (o) getNextChildId(o);
+  return createMemo(() => {
+    let conds = chs();
+    if (!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.length > 0 ? c(() => w) : c;
+      }
+    }
+    return props.fallback;
+  });
+}
+function Match(props) {
+  return props;
+}
+function Errored(props) {
+  return createErrorBoundary(() => props.children, (err, reset) => {
+    const f = props.fallback;
+    return typeof f === "function" && f.length ? f(err, reset) : f;
+  });
+}
+
+function ssrHandleError(err) {
+  if (err instanceof NotReadyError) {
+    return err.source;
+  }
+  const handler = getContext(ErrorContext);
+  if (handler) {
+    handler(err);
+    return;
+  }
+  throw err;
+}
+function Loading(props) {
+  const ctx = sharedConfig.context;
+  if (!ctx) {
+    return createLoadBoundary(() => props.children, () => props.fallback);
+  }
+  const o = createOwner();
+  const id = o.id;
+  o.id = 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 = createOwner({
+    id
+  });
+  getNextChildId(fallbackOwner);
+  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);
+}
+
+const DEV = undefined;
+
+export { $DEVCOMP, DEV, Errored, For, Loading, Match, Repeat, Show, Switch, action, children, createComponent, createContext, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createSignal, createStore, createTrackedEffect, createUniqueId, deep, enableHydration, flush, getObserver, isPending, isRefreshing, lazy, mapArray, onSettled, pending, reconcile, refresh, repeat, resolve, sharedConfig, ssrHandleError, ssrRunInScope, untrack, useContext };

package/dist/solid.cjs

@@ -28,27 +28,6 @@ function children(fn) {
   return memo;
 }
 
-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 sharedConfig = {
   hydrating: false,
   registry: undefined,
@@ -59,6 +38,77 @@ const sharedConfig = {
     return signals.getNextChildId(o);
   }
 };
+let _createMemo;
+let _createSignal;
+class MockPromise {
+  static all() {
+    return new MockPromise();
+  }
+  static allSettled() {
+    return new MockPromise();
+  }
+  static any() {
+    return new MockPromise();
+  }
+  static race() {
+    return new MockPromise();
+  }
+  static reject() {
+    return new MockPromise();
+  }
+  static resolve() {
+    return new MockPromise();
+  }
+  catch() {
+    return new MockPromise();
+  }
+  then() {
+    return new MockPromise();
+  }
+  finally() {
+    return new MockPromise();
+  }
+}
+function subFetch(fn, prev) {
+  const ogFetch = fetch;
+  const ogPromise = Promise;
+  try {
+    window.fetch = () => new MockPromise();
+    Promise = MockPromise;
+    return fn(prev);
+  } finally {
+    window.fetch = ogFetch;
+    Promise = ogPromise;
+  }
+}
+function hydratedCreateMemo(compute, value, options) {
+  if (!sharedConfig.hydrating) return signals.createMemo(compute, value, options);
+  return signals.createMemo(prev => {
+    const o = signals.getOwner();
+    if (!sharedConfig.hydrating) return compute(prev);
+    let initP;
+    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
+    const init = initP?.v ?? initP;
+    return init != null ? (subFetch(compute, prev), init) : compute(prev);
+  }, value, options);
+}
+function hydratedCreateSignal(fn, second, third) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return signals.createSignal(fn, second, third);
+  return signals.createSignal(prev => {
+    if (!sharedConfig.hydrating) return fn(prev);
+    const o = signals.getOwner();
+    let initP;
+    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
+    const init = initP?.v ?? initP;
+    return init != null ? (subFetch(fn, prev), init) : fn(prev);
+  }, second, third);
+}
+function enableHydration() {
+  _createMemo = hydratedCreateMemo;
+  _createSignal = hydratedCreateSignal;
+}
+const createMemo = (...args) => (_createMemo || signals.createMemo)(...args);
+const createSignal = (...args) => (_createSignal || signals.createSignal)(...args);
 function Loading(props) {
   if (!sharedConfig.hydrating) return signals.createLoadBoundary(() => props.children, () => props.fallback);
   return signals.createMemo(() => {
@@ -68,7 +118,7 @@ function Loading(props) {
       let ref = sharedConfig.load(id);
       let p;
       if (ref) {
-        if (typeof ref !== "object" || ref.s !== "success") p = ref;else sharedConfig.gather(id);
+        if (typeof ref !== "object" || ref.s !== 1) p = ref;else sharedConfig.gather(id);
       }
       if (p) {
         const [s, set] = signals.createSignal(undefined, {
@@ -93,8 +143,6 @@ function Loading(props) {
   });
 }
 
-function enableHydration() {
-}
 function createComponent(Comp, props) {
   return signals.untrack(() => Comp(props || {}));
 }
@@ -190,9 +238,6 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
-function Boundary(props) {
-  return signals.createBoundary(() => props.children, () => props.mode);
-}
 
 function ssrHandleError() {}
 function ssrRunInScope() {}
@@ -206,6 +251,10 @@ Object.defineProperty(exports, "$TRACK", {
   enumerable: true,
   get: function () { return signals.$TRACK; }
 });
+Object.defineProperty(exports, "NotReadyError", {
+  enumerable: true,
+  get: function () { return signals.NotReadyError; }
+});
 Object.defineProperty(exports, "action", {
   enumerable: true,
   get: function () { return signals.action; }
@@ -214,10 +263,6 @@ Object.defineProperty(exports, "createEffect", {
   enumerable: true,
   get: function () { return signals.createEffect; }
 });
-Object.defineProperty(exports, "createMemo", {
-  enumerable: true,
-  get: function () { return signals.createMemo; }
-});
 Object.defineProperty(exports, "createOptimistic", {
   enumerable: true,
   get: function () { return signals.createOptimistic; }
@@ -242,10 +287,6 @@ Object.defineProperty(exports, "createRoot", {
   enumerable: true,
   get: function () { return signals.createRoot; }
 });
-Object.defineProperty(exports, "createSignal", {
-  enumerable: true,
-  get: function () { return signals.createSignal; }
-});
 Object.defineProperty(exports, "createStore", {
   enumerable: true,
   get: function () { return signals.createStore; }
@@ -343,7 +384,6 @@ Object.defineProperty(exports, "untrack", {
   get: function () { return signals.untrack; }
 });
 exports.$DEVCOMP = $DEVCOMP;
-exports.Boundary = Boundary;
 exports.DEV = DEV;
 exports.Errored = Errored;
 exports.For = For;
@@ -355,12 +395,12 @@ exports.Switch = Switch;
 exports.children = children;
 exports.createComponent = createComponent;
 exports.createContext = createContext;
+exports.createMemo = createMemo;
+exports.createSignal = createSignal;
 exports.createUniqueId = createUniqueId;
 exports.enableHydration = enableHydration;
 exports.lazy = lazy;
-exports.reducer = reducer;
 exports.sharedConfig = sharedConfig;
 exports.ssrHandleError = ssrHandleError;
 exports.ssrRunInScope = ssrRunInScope;
-exports.tryCatch = tryCatch;
 exports.useContext = useContext;