1761 lines
48 KiB
JavaScript
1761 lines
48 KiB
JavaScript
// node_modules/.pnpm/solid-js@1.4.7/node_modules/solid-js/dist/dev.js
|
|
var taskIdCounter = 1;
|
|
var isCallbackScheduled = false;
|
|
var isPerformingWork = false;
|
|
var taskQueue = [];
|
|
var currentTask = null;
|
|
var shouldYieldToHost = null;
|
|
var yieldInterval = 5;
|
|
var deadline = 0;
|
|
var maxYieldInterval = 300;
|
|
var scheduleCallback = null;
|
|
var scheduledCallback = null;
|
|
var maxSigned31BitInt = 1073741823;
|
|
function setupScheduler() {
|
|
const channel = new MessageChannel(), port = channel.port2;
|
|
scheduleCallback = () => port.postMessage(null);
|
|
channel.port1.onmessage = () => {
|
|
if (scheduledCallback !== null) {
|
|
const currentTime = performance.now();
|
|
deadline = currentTime + yieldInterval;
|
|
const hasTimeRemaining = true;
|
|
try {
|
|
const hasMoreWork = scheduledCallback(hasTimeRemaining, currentTime);
|
|
if (!hasMoreWork) {
|
|
scheduledCallback = null;
|
|
} else
|
|
port.postMessage(null);
|
|
} catch (error) {
|
|
port.postMessage(null);
|
|
throw error;
|
|
}
|
|
}
|
|
};
|
|
if (navigator && navigator.scheduling && navigator.scheduling.isInputPending) {
|
|
const scheduling = navigator.scheduling;
|
|
shouldYieldToHost = () => {
|
|
const currentTime = performance.now();
|
|
if (currentTime >= deadline) {
|
|
if (scheduling.isInputPending()) {
|
|
return true;
|
|
}
|
|
return currentTime >= maxYieldInterval;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
} else {
|
|
shouldYieldToHost = () => performance.now() >= deadline;
|
|
}
|
|
}
|
|
function enqueue(taskQueue2, task) {
|
|
function findIndex() {
|
|
let m = 0;
|
|
let n = taskQueue2.length - 1;
|
|
while (m <= n) {
|
|
const k = n + m >> 1;
|
|
const cmp = task.expirationTime - taskQueue2[k].expirationTime;
|
|
if (cmp > 0)
|
|
m = k + 1;
|
|
else if (cmp < 0)
|
|
n = k - 1;
|
|
else
|
|
return k;
|
|
}
|
|
return m;
|
|
}
|
|
taskQueue2.splice(findIndex(), 0, task);
|
|
}
|
|
function requestCallback(fn, options) {
|
|
if (!scheduleCallback)
|
|
setupScheduler();
|
|
let startTime = performance.now(), timeout = maxSigned31BitInt;
|
|
if (options && options.timeout)
|
|
timeout = options.timeout;
|
|
const newTask = {
|
|
id: taskIdCounter++,
|
|
fn,
|
|
startTime,
|
|
expirationTime: startTime + timeout
|
|
};
|
|
enqueue(taskQueue, newTask);
|
|
if (!isCallbackScheduled && !isPerformingWork) {
|
|
isCallbackScheduled = true;
|
|
scheduledCallback = flushWork;
|
|
scheduleCallback();
|
|
}
|
|
return newTask;
|
|
}
|
|
function cancelCallback(task) {
|
|
task.fn = null;
|
|
}
|
|
function flushWork(hasTimeRemaining, initialTime) {
|
|
isCallbackScheduled = false;
|
|
isPerformingWork = true;
|
|
try {
|
|
return workLoop(hasTimeRemaining, initialTime);
|
|
} finally {
|
|
currentTask = null;
|
|
isPerformingWork = false;
|
|
}
|
|
}
|
|
function workLoop(hasTimeRemaining, initialTime) {
|
|
let currentTime = initialTime;
|
|
currentTask = taskQueue[0] || null;
|
|
while (currentTask !== null) {
|
|
if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
|
|
break;
|
|
}
|
|
const callback = currentTask.fn;
|
|
if (callback !== null) {
|
|
currentTask.fn = null;
|
|
const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
|
|
callback(didUserCallbackTimeout);
|
|
currentTime = performance.now();
|
|
if (currentTask === taskQueue[0]) {
|
|
taskQueue.shift();
|
|
}
|
|
} else
|
|
taskQueue.shift();
|
|
currentTask = taskQueue[0] || null;
|
|
}
|
|
return currentTask !== null;
|
|
}
|
|
var sharedConfig = {};
|
|
function setHydrateContext(context) {
|
|
sharedConfig.context = context;
|
|
}
|
|
function nextHydrateContext() {
|
|
return {
|
|
...sharedConfig.context,
|
|
id: `${sharedConfig.context.id}${sharedConfig.context.count++}-`,
|
|
count: 0
|
|
};
|
|
}
|
|
var equalFn = (a, b) => a === b;
|
|
var $PROXY = Symbol("solid-proxy");
|
|
var $TRACK = Symbol("solid-track");
|
|
var $DEVCOMP = Symbol("solid-dev-component");
|
|
var signalOptions = {
|
|
equals: equalFn
|
|
};
|
|
var ERROR = null;
|
|
var runEffects = runQueue;
|
|
var NOTPENDING = {};
|
|
var STALE = 1;
|
|
var PENDING = 2;
|
|
var UNOWNED = {
|
|
owned: null,
|
|
cleanups: null,
|
|
context: null,
|
|
owner: null
|
|
};
|
|
var [transPending, setTransPending] = createSignal(false);
|
|
var Owner = null;
|
|
var Transition = null;
|
|
var Scheduler = null;
|
|
var ExternalSourceFactory = null;
|
|
var Listener = null;
|
|
var Pending = null;
|
|
var Updates = null;
|
|
var Effects = null;
|
|
var ExecCount = 0;
|
|
var rootCount = 0;
|
|
function createRoot(fn, detachedOwner) {
|
|
const listener = Listener, owner = Owner, unowned = fn.length === 0, root = unowned && false ? UNOWNED : {
|
|
owned: null,
|
|
cleanups: null,
|
|
context: null,
|
|
owner: detachedOwner || owner
|
|
}, updateFn = unowned ? () => fn(() => {
|
|
throw new Error("Dispose method must be an explicit argument to createRoot function");
|
|
}) : () => fn(() => cleanNode(root));
|
|
{
|
|
if (owner)
|
|
root.name = `${owner.name}-r${rootCount++}`;
|
|
globalThis._$afterCreateRoot && globalThis._$afterCreateRoot(root);
|
|
}
|
|
Owner = root;
|
|
Listener = null;
|
|
try {
|
|
return runUpdates(updateFn, true);
|
|
} finally {
|
|
Listener = listener;
|
|
Owner = owner;
|
|
}
|
|
}
|
|
function createSignal(value, options) {
|
|
options = options ? Object.assign({}, signalOptions, options) : signalOptions;
|
|
const s = {
|
|
value,
|
|
observers: null,
|
|
observerSlots: null,
|
|
pending: NOTPENDING,
|
|
comparator: options.equals || void 0
|
|
};
|
|
if (!options.internal)
|
|
s.name = registerGraph(options.name || hashValue(value), s);
|
|
const setter = (value2) => {
|
|
if (typeof value2 === "function") {
|
|
if (Transition && Transition.running && Transition.sources.has(s))
|
|
value2 = value2(s.pending !== NOTPENDING ? s.pending : s.tValue);
|
|
else
|
|
value2 = value2(s.pending !== NOTPENDING ? s.pending : s.value);
|
|
}
|
|
return writeSignal(s, value2);
|
|
};
|
|
return [readSignal.bind(s), setter];
|
|
}
|
|
function createComputed(fn, value, options) {
|
|
const c = createComputation(fn, value, true, STALE, options);
|
|
if (Scheduler && Transition && Transition.running)
|
|
Updates.push(c);
|
|
else
|
|
updateComputation(c);
|
|
}
|
|
function createRenderEffect(fn, value, options) {
|
|
const c = createComputation(fn, value, false, STALE, options);
|
|
if (Scheduler && Transition && Transition.running)
|
|
Updates.push(c);
|
|
else
|
|
updateComputation(c);
|
|
}
|
|
function createEffect(fn, value, options) {
|
|
runEffects = runUserEffects;
|
|
const c = createComputation(fn, value, false, STALE, options), s = SuspenseContext && lookup(Owner, SuspenseContext.id);
|
|
if (s)
|
|
c.suspense = s;
|
|
c.user = true;
|
|
Effects ? Effects.push(c) : updateComputation(c);
|
|
}
|
|
function createReaction(onInvalidate, options) {
|
|
let fn;
|
|
const c = createComputation(() => {
|
|
fn ? fn() : untrack(onInvalidate);
|
|
fn = void 0;
|
|
}, void 0, false, 0, options), s = SuspenseContext && lookup(Owner, SuspenseContext.id);
|
|
if (s)
|
|
c.suspense = s;
|
|
c.user = true;
|
|
return (tracking) => {
|
|
fn = tracking;
|
|
updateComputation(c);
|
|
};
|
|
}
|
|
function createMemo(fn, value, options) {
|
|
options = options ? Object.assign({}, signalOptions, options) : signalOptions;
|
|
const c = createComputation(fn, value, true, 0, options);
|
|
c.pending = NOTPENDING;
|
|
c.observers = null;
|
|
c.observerSlots = null;
|
|
c.comparator = options.equals || void 0;
|
|
if (Scheduler && Transition && Transition.running) {
|
|
c.tState = STALE;
|
|
Updates.push(c);
|
|
} else
|
|
updateComputation(c);
|
|
return readSignal.bind(c);
|
|
}
|
|
function createResource(source, fetcher, options) {
|
|
if (arguments.length === 2) {
|
|
if (typeof fetcher === "object") {
|
|
options = fetcher;
|
|
fetcher = source;
|
|
source = true;
|
|
}
|
|
} else if (arguments.length === 1) {
|
|
fetcher = source;
|
|
source = true;
|
|
}
|
|
options || (options = {});
|
|
const contexts = /* @__PURE__ */ new Set(), [value, setValue] = createSignal(options.initialValue), [track, trigger] = createSignal(void 0, {
|
|
equals: false
|
|
}), [loading, setLoading] = createSignal(false), [error, setError] = createSignal();
|
|
let err = void 0, pr = null, initP = null, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
|
|
if (sharedConfig.context) {
|
|
id = `${sharedConfig.context.id}${sharedConfig.context.count++}`;
|
|
if (sharedConfig.load)
|
|
initP = sharedConfig.load(id);
|
|
}
|
|
function loadEnd(p, v, e, key) {
|
|
if (pr === p) {
|
|
pr = null;
|
|
resolved = true;
|
|
if (initP && (p === initP || v === initP) && options.onHydrated)
|
|
queueMicrotask(() => options.onHydrated(key, {
|
|
value: v
|
|
}));
|
|
initP = null;
|
|
setError(err = e);
|
|
if (Transition && p && loadedUnderTransition) {
|
|
Transition.promises.delete(p);
|
|
loadedUnderTransition = false;
|
|
runUpdates(() => {
|
|
Transition.running = true;
|
|
if (!Transition.promises.size) {
|
|
Effects.push.apply(Effects, Transition.effects);
|
|
Transition.effects = [];
|
|
}
|
|
completeLoad(v);
|
|
}, false);
|
|
} else
|
|
completeLoad(v);
|
|
}
|
|
return v;
|
|
}
|
|
function completeLoad(v) {
|
|
batch(() => {
|
|
setValue(() => v);
|
|
setLoading(false);
|
|
for (const c of contexts.keys())
|
|
c.decrement();
|
|
contexts.clear();
|
|
});
|
|
}
|
|
function read() {
|
|
const c = SuspenseContext && lookup(Owner, SuspenseContext.id), v = value();
|
|
if (err)
|
|
throw err;
|
|
if (Listener && !Listener.user && c) {
|
|
createComputed(() => {
|
|
track();
|
|
if (pr) {
|
|
if (c.resolved && Transition)
|
|
Transition.promises.add(pr);
|
|
else if (!contexts.has(c)) {
|
|
c.increment();
|
|
contexts.add(c);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return v;
|
|
}
|
|
function load(refetching = true) {
|
|
if (refetching && scheduled)
|
|
return;
|
|
scheduled = false;
|
|
setError(err = void 0);
|
|
const lookup2 = dynamic ? dynamic() : source;
|
|
loadedUnderTransition = Transition && Transition.running;
|
|
if (lookup2 == null || lookup2 === false) {
|
|
loadEnd(pr, untrack(value));
|
|
return;
|
|
}
|
|
if (Transition && pr)
|
|
Transition.promises.delete(pr);
|
|
const p = initP || untrack(() => fetcher(lookup2, {
|
|
value: value(),
|
|
refetching
|
|
}));
|
|
if (typeof p !== "object" || !("then" in p)) {
|
|
loadEnd(pr, p);
|
|
return p;
|
|
}
|
|
pr = p;
|
|
scheduled = true;
|
|
queueMicrotask(() => scheduled = false);
|
|
batch(() => {
|
|
setLoading(true);
|
|
trigger();
|
|
});
|
|
return p.then((v) => loadEnd(p, v, void 0, lookup2), (e) => loadEnd(p, e, e));
|
|
}
|
|
Object.defineProperties(read, {
|
|
loading: {
|
|
get() {
|
|
return loading();
|
|
}
|
|
},
|
|
error: {
|
|
get() {
|
|
return error();
|
|
}
|
|
},
|
|
latest: {
|
|
get() {
|
|
if (!resolved)
|
|
return read();
|
|
if (err)
|
|
throw err;
|
|
return value();
|
|
}
|
|
}
|
|
});
|
|
if (dynamic)
|
|
createComputed(() => load(false));
|
|
else
|
|
load(false);
|
|
return [read, {
|
|
refetch: load,
|
|
mutate: setValue
|
|
}];
|
|
}
|
|
function createDeferred(source, options) {
|
|
let t, timeout = options ? options.timeoutMs : void 0;
|
|
const node = createComputation(() => {
|
|
if (!t || !t.fn)
|
|
t = requestCallback(() => setDeferred(() => node.value), timeout !== void 0 ? {
|
|
timeout
|
|
} : void 0);
|
|
return source();
|
|
}, void 0, true);
|
|
const [deferred, setDeferred] = createSignal(node.value, options);
|
|
updateComputation(node);
|
|
setDeferred(() => node.value);
|
|
return deferred;
|
|
}
|
|
function createSelector(source, fn = equalFn, options) {
|
|
const subs = /* @__PURE__ */ new Map();
|
|
const node = createComputation((p) => {
|
|
const v = source();
|
|
for (const key of subs.keys())
|
|
if (fn(key, v) !== fn(key, p)) {
|
|
const l = subs.get(key);
|
|
for (const c of l.values()) {
|
|
c.state = STALE;
|
|
if (c.pure)
|
|
Updates.push(c);
|
|
else
|
|
Effects.push(c);
|
|
}
|
|
}
|
|
return v;
|
|
}, void 0, true, STALE, options);
|
|
updateComputation(node);
|
|
return (key) => {
|
|
let listener;
|
|
if (listener = Listener) {
|
|
let l;
|
|
if (l = subs.get(key))
|
|
l.add(listener);
|
|
else
|
|
subs.set(key, l = /* @__PURE__ */ new Set([listener]));
|
|
onCleanup(() => {
|
|
l.delete(listener);
|
|
!l.size && subs.delete(key);
|
|
});
|
|
}
|
|
return fn(key, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
|
|
};
|
|
}
|
|
function batch(fn) {
|
|
if (Pending)
|
|
return fn();
|
|
let result;
|
|
const q = Pending = [];
|
|
try {
|
|
result = fn();
|
|
} finally {
|
|
Pending = null;
|
|
}
|
|
runUpdates(() => {
|
|
for (let i = 0; i < q.length; i += 1) {
|
|
const data = q[i];
|
|
if (data.pending !== NOTPENDING) {
|
|
const pending = data.pending;
|
|
data.pending = NOTPENDING;
|
|
writeSignal(data, pending);
|
|
}
|
|
}
|
|
}, false);
|
|
return result;
|
|
}
|
|
function untrack(fn) {
|
|
let result, listener = Listener;
|
|
Listener = null;
|
|
result = fn();
|
|
Listener = listener;
|
|
return result;
|
|
}
|
|
function on(deps, fn, options) {
|
|
const isArray = Array.isArray(deps);
|
|
let prevInput;
|
|
let defer = options && options.defer;
|
|
return (prevValue) => {
|
|
let input;
|
|
if (isArray) {
|
|
input = Array(deps.length);
|
|
for (let i = 0; i < deps.length; i++)
|
|
input[i] = deps[i]();
|
|
} else
|
|
input = deps();
|
|
if (defer) {
|
|
defer = false;
|
|
return void 0;
|
|
}
|
|
const result = untrack(() => fn(input, prevInput, prevValue));
|
|
prevInput = input;
|
|
return result;
|
|
};
|
|
}
|
|
function onMount(fn) {
|
|
createEffect(() => untrack(fn));
|
|
}
|
|
function onCleanup(fn) {
|
|
if (Owner === null)
|
|
console.warn("cleanups created outside a `createRoot` or `render` will never be run");
|
|
else if (Owner.cleanups === null)
|
|
Owner.cleanups = [fn];
|
|
else
|
|
Owner.cleanups.push(fn);
|
|
return fn;
|
|
}
|
|
function onError(fn) {
|
|
ERROR || (ERROR = Symbol("error"));
|
|
if (Owner === null)
|
|
console.warn("error handlers created outside a `createRoot` or `render` will never be run");
|
|
else if (Owner.context === null)
|
|
Owner.context = {
|
|
[ERROR]: [fn]
|
|
};
|
|
else if (!Owner.context[ERROR])
|
|
Owner.context[ERROR] = [fn];
|
|
else
|
|
Owner.context[ERROR].push(fn);
|
|
}
|
|
function getListener() {
|
|
return Listener;
|
|
}
|
|
function getOwner() {
|
|
return Owner;
|
|
}
|
|
function runWithOwner(o, fn) {
|
|
const prev = Owner;
|
|
Owner = o;
|
|
try {
|
|
return runUpdates(fn, true);
|
|
} finally {
|
|
Owner = prev;
|
|
}
|
|
}
|
|
function enableScheduling(scheduler = requestCallback) {
|
|
Scheduler = scheduler;
|
|
}
|
|
function startTransition(fn) {
|
|
if (Transition && Transition.running) {
|
|
fn();
|
|
return Transition.done;
|
|
}
|
|
const l = Listener;
|
|
const o = Owner;
|
|
return Promise.resolve().then(() => {
|
|
Listener = l;
|
|
Owner = o;
|
|
let t;
|
|
if (Scheduler || SuspenseContext) {
|
|
t = Transition || (Transition = {
|
|
sources: /* @__PURE__ */ new Set(),
|
|
effects: [],
|
|
promises: /* @__PURE__ */ new Set(),
|
|
disposed: /* @__PURE__ */ new Set(),
|
|
queue: /* @__PURE__ */ new Set(),
|
|
running: true
|
|
});
|
|
t.done || (t.done = new Promise((res) => t.resolve = res));
|
|
t.running = true;
|
|
}
|
|
batch(fn);
|
|
Listener = Owner = null;
|
|
return t ? t.done : void 0;
|
|
});
|
|
}
|
|
function useTransition() {
|
|
return [transPending, startTransition];
|
|
}
|
|
function resumeEffects(e) {
|
|
Effects.push.apply(Effects, e);
|
|
e.length = 0;
|
|
}
|
|
function devComponent(Comp, props) {
|
|
const c = createComputation(() => untrack(() => {
|
|
Object.assign(Comp, {
|
|
[$DEVCOMP]: true
|
|
});
|
|
return Comp(props);
|
|
}), void 0, true);
|
|
c.pending = NOTPENDING;
|
|
c.observers = null;
|
|
c.observerSlots = null;
|
|
c.state = 0;
|
|
c.componentName = Comp.name;
|
|
updateComputation(c);
|
|
return c.tValue !== void 0 ? c.tValue : c.value;
|
|
}
|
|
function hashValue(v) {
|
|
const s = /* @__PURE__ */ new Set();
|
|
return `s${typeof v === "string" ? hash(v) : hash(JSON.stringify(v, (k, v2) => {
|
|
if (typeof v2 === "object" && v2 != null) {
|
|
if (s.has(v2))
|
|
return;
|
|
s.add(v2);
|
|
const keys = Object.keys(v2);
|
|
const desc = Object.getOwnPropertyDescriptors(v2);
|
|
const newDesc = keys.reduce((memo, key) => {
|
|
const value = desc[key];
|
|
if (!value.get)
|
|
memo[key] = value;
|
|
return memo;
|
|
}, {});
|
|
v2 = Object.create({}, newDesc);
|
|
}
|
|
if (typeof v2 === "bigint") {
|
|
return `${v2.toString()}n`;
|
|
}
|
|
return v2;
|
|
}) || "")}`;
|
|
}
|
|
function registerGraph(name, value) {
|
|
let tryName = name;
|
|
if (Owner) {
|
|
let i = 0;
|
|
Owner.sourceMap || (Owner.sourceMap = {});
|
|
while (Owner.sourceMap[tryName])
|
|
tryName = `${name}-${++i}`;
|
|
Owner.sourceMap[tryName] = value;
|
|
}
|
|
return tryName;
|
|
}
|
|
function serializeGraph(owner) {
|
|
owner || (owner = Owner);
|
|
if (!owner)
|
|
return {};
|
|
return {
|
|
...serializeValues(owner.sourceMap),
|
|
...owner.owned ? serializeChildren(owner) : {}
|
|
};
|
|
}
|
|
function createContext(defaultValue) {
|
|
const id = Symbol("context");
|
|
return {
|
|
id,
|
|
Provider: createProvider(id),
|
|
defaultValue
|
|
};
|
|
}
|
|
function useContext(context) {
|
|
let ctx;
|
|
return (ctx = lookup(Owner, context.id)) !== void 0 ? ctx : context.defaultValue;
|
|
}
|
|
function children(fn) {
|
|
const children2 = createMemo(fn);
|
|
return createMemo(() => resolveChildren(children2()));
|
|
}
|
|
var SuspenseContext;
|
|
function getSuspenseContext() {
|
|
return SuspenseContext || (SuspenseContext = createContext({}));
|
|
}
|
|
function enableExternalSource(factory) {
|
|
if (ExternalSourceFactory) {
|
|
const oldFactory = ExternalSourceFactory;
|
|
ExternalSourceFactory = (fn, trigger) => {
|
|
const oldSource = oldFactory(fn, trigger);
|
|
const source = factory((x) => oldSource.track(x), trigger);
|
|
return {
|
|
track: (x) => source.track(x),
|
|
dispose() {
|
|
source.dispose();
|
|
oldSource.dispose();
|
|
}
|
|
};
|
|
};
|
|
} else {
|
|
ExternalSourceFactory = factory;
|
|
}
|
|
}
|
|
function readSignal() {
|
|
const runningTransition = Transition && Transition.running;
|
|
if (this.sources && (!runningTransition && this.state || runningTransition && this.tState)) {
|
|
const updates = Updates;
|
|
Updates = null;
|
|
!runningTransition && this.state === STALE || runningTransition && this.tState === STALE ? updateComputation(this) : lookUpstream(this);
|
|
Updates = updates;
|
|
}
|
|
if (Listener) {
|
|
const sSlot = this.observers ? this.observers.length : 0;
|
|
if (!Listener.sources) {
|
|
Listener.sources = [this];
|
|
Listener.sourceSlots = [sSlot];
|
|
} else {
|
|
Listener.sources.push(this);
|
|
Listener.sourceSlots.push(sSlot);
|
|
}
|
|
if (!this.observers) {
|
|
this.observers = [Listener];
|
|
this.observerSlots = [Listener.sources.length - 1];
|
|
} else {
|
|
this.observers.push(Listener);
|
|
this.observerSlots.push(Listener.sources.length - 1);
|
|
}
|
|
}
|
|
if (runningTransition && Transition.sources.has(this))
|
|
return this.tValue;
|
|
return this.value;
|
|
}
|
|
function writeSignal(node, value, isComp) {
|
|
if (Pending) {
|
|
if (node.pending === NOTPENDING)
|
|
Pending.push(node);
|
|
node.pending = value;
|
|
return value;
|
|
}
|
|
if (node.comparator) {
|
|
if (Transition && Transition.running && Transition.sources.has(node)) {
|
|
if (node.comparator(node.tValue, value))
|
|
return value;
|
|
} else if (node.comparator(node.value, value))
|
|
return value;
|
|
}
|
|
let TransitionRunning = false;
|
|
if (Transition) {
|
|
TransitionRunning = Transition.running;
|
|
if (TransitionRunning || !isComp && Transition.sources.has(node)) {
|
|
Transition.sources.add(node);
|
|
node.tValue = value;
|
|
}
|
|
if (!TransitionRunning)
|
|
node.value = value;
|
|
} else
|
|
node.value = value;
|
|
if (node.observers && node.observers.length) {
|
|
runUpdates(() => {
|
|
for (let i = 0; i < node.observers.length; i += 1) {
|
|
const o = node.observers[i];
|
|
if (TransitionRunning && Transition.disposed.has(o))
|
|
continue;
|
|
if (TransitionRunning && !o.tState || !TransitionRunning && !o.state) {
|
|
if (o.pure)
|
|
Updates.push(o);
|
|
else
|
|
Effects.push(o);
|
|
if (o.observers)
|
|
markDownstream(o);
|
|
}
|
|
if (TransitionRunning)
|
|
o.tState = STALE;
|
|
else
|
|
o.state = STALE;
|
|
}
|
|
if (Updates.length > 1e6) {
|
|
Updates = [];
|
|
if ("_SOLID_DEV_")
|
|
throw new Error("Potential Infinite Loop Detected.");
|
|
throw new Error();
|
|
}
|
|
}, false);
|
|
}
|
|
return value;
|
|
}
|
|
function updateComputation(node) {
|
|
if (!node.fn)
|
|
return;
|
|
cleanNode(node);
|
|
const owner = Owner, listener = Listener, time = ExecCount;
|
|
Listener = Owner = node;
|
|
runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
|
|
if (Transition && !Transition.running && Transition.sources.has(node)) {
|
|
queueMicrotask(() => {
|
|
runUpdates(() => {
|
|
Transition && (Transition.running = true);
|
|
runComputation(node, node.tValue, time);
|
|
}, false);
|
|
});
|
|
}
|
|
Listener = listener;
|
|
Owner = owner;
|
|
}
|
|
function runComputation(node, value, time) {
|
|
let nextValue;
|
|
try {
|
|
nextValue = node.fn(value);
|
|
} catch (err) {
|
|
handleError(err);
|
|
}
|
|
if (!node.updatedAt || node.updatedAt <= time) {
|
|
if (node.observers && node.observers.length) {
|
|
writeSignal(node, nextValue, true);
|
|
} else if (Transition && Transition.running && node.pure) {
|
|
Transition.sources.add(node);
|
|
node.tValue = nextValue;
|
|
} else
|
|
node.value = nextValue;
|
|
node.updatedAt = time;
|
|
}
|
|
}
|
|
function createComputation(fn, init, pure, state = STALE, options) {
|
|
const c = {
|
|
fn,
|
|
state,
|
|
updatedAt: null,
|
|
owned: null,
|
|
sources: null,
|
|
sourceSlots: null,
|
|
cleanups: null,
|
|
value: init,
|
|
owner: Owner,
|
|
context: null,
|
|
pure
|
|
};
|
|
if (Transition && Transition.running) {
|
|
c.state = 0;
|
|
c.tState = state;
|
|
}
|
|
if (Owner === null)
|
|
console.warn("computations created outside a `createRoot` or `render` will never be disposed");
|
|
else if (Owner !== UNOWNED) {
|
|
if (Transition && Transition.running && Owner.pure) {
|
|
if (!Owner.tOwned)
|
|
Owner.tOwned = [c];
|
|
else
|
|
Owner.tOwned.push(c);
|
|
} else {
|
|
if (!Owner.owned)
|
|
Owner.owned = [c];
|
|
else
|
|
Owner.owned.push(c);
|
|
}
|
|
c.name = options && options.name || `${Owner.name || "c"}-${(Owner.owned || Owner.tOwned).length}`;
|
|
}
|
|
if (ExternalSourceFactory) {
|
|
const [track, trigger] = createSignal(void 0, {
|
|
equals: false
|
|
});
|
|
const ordinary = ExternalSourceFactory(c.fn, trigger);
|
|
onCleanup(() => ordinary.dispose());
|
|
const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
|
|
const inTransition = ExternalSourceFactory(c.fn, triggerInTransition);
|
|
c.fn = (x) => {
|
|
track();
|
|
return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
|
|
};
|
|
}
|
|
return c;
|
|
}
|
|
function runTop(node) {
|
|
const runningTransition = Transition && Transition.running;
|
|
if (!runningTransition && node.state === 0 || runningTransition && node.tState === 0)
|
|
return;
|
|
if (!runningTransition && node.state === PENDING || runningTransition && node.tState === PENDING)
|
|
return lookUpstream(node);
|
|
if (node.suspense && untrack(node.suspense.inFallback))
|
|
return node.suspense.effects.push(node);
|
|
const ancestors = [node];
|
|
while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
|
|
if (runningTransition && Transition.disposed.has(node))
|
|
return;
|
|
if (!runningTransition && node.state || runningTransition && node.tState)
|
|
ancestors.push(node);
|
|
}
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
node = ancestors[i];
|
|
if (runningTransition) {
|
|
let top = node, prev = ancestors[i + 1];
|
|
while ((top = top.owner) && top !== prev) {
|
|
if (Transition.disposed.has(top))
|
|
return;
|
|
}
|
|
}
|
|
if (!runningTransition && node.state === STALE || runningTransition && node.tState === STALE) {
|
|
updateComputation(node);
|
|
} else if (!runningTransition && node.state === PENDING || runningTransition && node.tState === PENDING) {
|
|
const updates = Updates;
|
|
Updates = null;
|
|
lookUpstream(node, ancestors[0]);
|
|
Updates = updates;
|
|
}
|
|
}
|
|
}
|
|
function runUpdates(fn, init) {
|
|
if (Updates)
|
|
return fn();
|
|
let wait = false;
|
|
if (!init)
|
|
Updates = [];
|
|
if (Effects)
|
|
wait = true;
|
|
else
|
|
Effects = [];
|
|
ExecCount++;
|
|
try {
|
|
const res = fn();
|
|
completeUpdates(wait);
|
|
return res;
|
|
} catch (err) {
|
|
if (!Updates)
|
|
Effects = null;
|
|
handleError(err);
|
|
}
|
|
}
|
|
function completeUpdates(wait) {
|
|
if (Updates) {
|
|
if (Scheduler && Transition && Transition.running)
|
|
scheduleQueue(Updates);
|
|
else
|
|
runQueue(Updates);
|
|
Updates = null;
|
|
}
|
|
if (wait)
|
|
return;
|
|
let res;
|
|
if (Transition && Transition.running) {
|
|
if (Transition.promises.size || Transition.queue.size) {
|
|
Transition.running = false;
|
|
Transition.effects.push.apply(Transition.effects, Effects);
|
|
Effects = null;
|
|
setTransPending(true);
|
|
return;
|
|
}
|
|
const sources = Transition.sources;
|
|
const disposed = Transition.disposed;
|
|
res = Transition.resolve;
|
|
for (const e of Effects) {
|
|
"tState" in e && (e.state = e.tState);
|
|
delete e.tState;
|
|
}
|
|
Transition = null;
|
|
batch(() => {
|
|
for (const d of disposed)
|
|
cleanNode(d);
|
|
for (const v of sources) {
|
|
v.value = v.tValue;
|
|
if (v.owned) {
|
|
for (let i = 0, len = v.owned.length; i < len; i++)
|
|
cleanNode(v.owned[i]);
|
|
}
|
|
if (v.tOwned)
|
|
v.owned = v.tOwned;
|
|
delete v.tValue;
|
|
delete v.tOwned;
|
|
v.tState = 0;
|
|
}
|
|
setTransPending(false);
|
|
});
|
|
}
|
|
if (Effects.length)
|
|
batch(() => {
|
|
runEffects(Effects);
|
|
Effects = null;
|
|
});
|
|
else {
|
|
Effects = null;
|
|
globalThis._$afterUpdate && globalThis._$afterUpdate();
|
|
}
|
|
if (res)
|
|
res();
|
|
}
|
|
function runQueue(queue) {
|
|
for (let i = 0; i < queue.length; i++)
|
|
runTop(queue[i]);
|
|
}
|
|
function scheduleQueue(queue) {
|
|
for (let i = 0; i < queue.length; i++) {
|
|
const item = queue[i];
|
|
const tasks = Transition.queue;
|
|
if (!tasks.has(item)) {
|
|
tasks.add(item);
|
|
Scheduler(() => {
|
|
tasks.delete(item);
|
|
runUpdates(() => {
|
|
Transition.running = true;
|
|
runTop(item);
|
|
if (!tasks.size) {
|
|
Effects.push.apply(Effects, Transition.effects);
|
|
Transition.effects = [];
|
|
}
|
|
}, false);
|
|
Transition && (Transition.running = false);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function runUserEffects(queue) {
|
|
let i, userLength = 0;
|
|
for (i = 0; i < queue.length; i++) {
|
|
const e = queue[i];
|
|
if (!e.user)
|
|
runTop(e);
|
|
else
|
|
queue[userLength++] = e;
|
|
}
|
|
if (sharedConfig.context)
|
|
setHydrateContext();
|
|
const resume = queue.length;
|
|
for (i = 0; i < userLength; i++)
|
|
runTop(queue[i]);
|
|
for (i = resume; i < queue.length; i++)
|
|
runTop(queue[i]);
|
|
}
|
|
function lookUpstream(node, ignore) {
|
|
const runningTransition = Transition && Transition.running;
|
|
if (runningTransition)
|
|
node.tState = 0;
|
|
else
|
|
node.state = 0;
|
|
for (let i = 0; i < node.sources.length; i += 1) {
|
|
const source = node.sources[i];
|
|
if (source.sources) {
|
|
if (!runningTransition && source.state === STALE || runningTransition && source.tState === STALE) {
|
|
if (source !== ignore)
|
|
runTop(source);
|
|
} else if (!runningTransition && source.state === PENDING || runningTransition && source.tState === PENDING)
|
|
lookUpstream(source, ignore);
|
|
}
|
|
}
|
|
}
|
|
function markDownstream(node) {
|
|
const runningTransition = Transition && Transition.running;
|
|
for (let i = 0; i < node.observers.length; i += 1) {
|
|
const o = node.observers[i];
|
|
if (!runningTransition && !o.state || runningTransition && !o.tState) {
|
|
if (runningTransition)
|
|
o.tState = PENDING;
|
|
else
|
|
o.state = PENDING;
|
|
if (o.pure)
|
|
Updates.push(o);
|
|
else
|
|
Effects.push(o);
|
|
o.observers && markDownstream(o);
|
|
}
|
|
}
|
|
}
|
|
function cleanNode(node) {
|
|
let i;
|
|
if (node.sources) {
|
|
while (node.sources.length) {
|
|
const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
|
|
if (obs && obs.length) {
|
|
const n = obs.pop(), s = source.observerSlots.pop();
|
|
if (index < obs.length) {
|
|
n.sourceSlots[s] = index;
|
|
obs[index] = n;
|
|
source.observerSlots[index] = s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Transition && Transition.running && node.pure) {
|
|
if (node.tOwned) {
|
|
for (i = 0; i < node.tOwned.length; i++)
|
|
cleanNode(node.tOwned[i]);
|
|
delete node.tOwned;
|
|
}
|
|
reset(node, true);
|
|
} else if (node.owned) {
|
|
for (i = 0; i < node.owned.length; i++)
|
|
cleanNode(node.owned[i]);
|
|
node.owned = null;
|
|
}
|
|
if (node.cleanups) {
|
|
for (i = 0; i < node.cleanups.length; i++)
|
|
node.cleanups[i]();
|
|
node.cleanups = null;
|
|
}
|
|
if (Transition && Transition.running)
|
|
node.tState = 0;
|
|
else
|
|
node.state = 0;
|
|
node.context = null;
|
|
delete node.sourceMap;
|
|
}
|
|
function reset(node, top) {
|
|
if (!top) {
|
|
node.tState = 0;
|
|
Transition.disposed.add(node);
|
|
}
|
|
if (node.owned) {
|
|
for (let i = 0; i < node.owned.length; i++)
|
|
reset(node.owned[i]);
|
|
}
|
|
}
|
|
function handleError(err) {
|
|
const fns = ERROR && lookup(Owner, ERROR);
|
|
if (!fns)
|
|
throw err;
|
|
for (const f of fns)
|
|
f(err);
|
|
}
|
|
function lookup(owner, key) {
|
|
return owner ? owner.context && owner.context[key] !== void 0 ? owner.context[key] : lookup(owner.owner, key) : void 0;
|
|
}
|
|
function resolveChildren(children2) {
|
|
if (typeof children2 === "function" && !children2.length)
|
|
return resolveChildren(children2());
|
|
if (Array.isArray(children2)) {
|
|
const results = [];
|
|
for (let i = 0; i < children2.length; i++) {
|
|
const result = resolveChildren(children2[i]);
|
|
Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
|
|
}
|
|
return results;
|
|
}
|
|
return children2;
|
|
}
|
|
function createProvider(id) {
|
|
return function provider(props) {
|
|
let res;
|
|
createComputed(() => res = untrack(() => {
|
|
Owner.context = {
|
|
[id]: props.value
|
|
};
|
|
return children(() => props.children);
|
|
}));
|
|
return res;
|
|
};
|
|
}
|
|
function hash(s) {
|
|
for (var i = 0, h = 9; i < s.length; )
|
|
h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
|
|
return `${h ^ h >>> 9}`;
|
|
}
|
|
function serializeValues(sources = {}) {
|
|
const k = Object.keys(sources);
|
|
const result = {};
|
|
for (let i = 0; i < k.length; i++) {
|
|
const key = k[i];
|
|
result[key] = sources[key].value;
|
|
}
|
|
return result;
|
|
}
|
|
function serializeChildren(root) {
|
|
const result = {};
|
|
for (let i = 0, len = root.owned.length; i < len; i++) {
|
|
const node = root.owned[i];
|
|
result[node.componentName ? `${node.componentName}:${node.name}` : node.name] = {
|
|
...serializeValues(node.sourceMap),
|
|
...node.owned ? serializeChildren(node) : {}
|
|
};
|
|
}
|
|
return result;
|
|
}
|
|
function getSymbol() {
|
|
const SymbolCopy = Symbol;
|
|
return SymbolCopy.observable || "@@observable";
|
|
}
|
|
function observable(input) {
|
|
const $$observable = getSymbol();
|
|
return {
|
|
subscribe(observer) {
|
|
if (!(observer instanceof Object) || observer == null) {
|
|
throw new TypeError("Expected the observer to be an object.");
|
|
}
|
|
const handler = "next" in observer ? observer.next.bind(observer) : observer;
|
|
let complete = false;
|
|
createComputed(() => {
|
|
if (complete)
|
|
return;
|
|
const v = input();
|
|
untrack(() => handler(v));
|
|
});
|
|
return {
|
|
unsubscribe() {
|
|
complete = true;
|
|
}
|
|
};
|
|
},
|
|
[$$observable]() {
|
|
return this;
|
|
}
|
|
};
|
|
}
|
|
function from(producer) {
|
|
const [s, set] = createSignal(void 0, {
|
|
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;
|
|
}
|
|
var FALLBACK = Symbol("fallback");
|
|
function dispose(d) {
|
|
for (let i = 0; i < d.length; i++)
|
|
d[i]();
|
|
}
|
|
function mapArray(list, mapFn, options = {}) {
|
|
let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
|
|
onCleanup(() => dispose(disposers));
|
|
return () => {
|
|
let newItems = list() || [], i, j;
|
|
newItems[$TRACK];
|
|
return untrack(() => {
|
|
let newLen = newItems.length, newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
|
|
if (newLen === 0) {
|
|
if (len !== 0) {
|
|
dispose(disposers);
|
|
disposers = [];
|
|
items = [];
|
|
mapped = [];
|
|
len = 0;
|
|
indexes && (indexes = []);
|
|
}
|
|
if (options.fallback) {
|
|
items = [FALLBACK];
|
|
mapped[0] = createRoot((disposer) => {
|
|
disposers[0] = disposer;
|
|
return options.fallback();
|
|
});
|
|
len = 1;
|
|
}
|
|
} else if (len === 0) {
|
|
mapped = new Array(newLen);
|
|
for (j = 0; j < newLen; j++) {
|
|
items[j] = newItems[j];
|
|
mapped[j] = createRoot(mapper);
|
|
}
|
|
len = newLen;
|
|
} else {
|
|
temp = new Array(newLen);
|
|
tempdisposers = new Array(newLen);
|
|
indexes && (tempIndexes = new Array(newLen));
|
|
for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++)
|
|
;
|
|
for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
|
|
temp[newEnd] = mapped[end];
|
|
tempdisposers[newEnd] = disposers[end];
|
|
indexes && (tempIndexes[newEnd] = indexes[end]);
|
|
}
|
|
newIndices = /* @__PURE__ */ new Map();
|
|
newIndicesNext = new Array(newEnd + 1);
|
|
for (j = newEnd; j >= start; j--) {
|
|
item = newItems[j];
|
|
i = newIndices.get(item);
|
|
newIndicesNext[j] = i === void 0 ? -1 : i;
|
|
newIndices.set(item, j);
|
|
}
|
|
for (i = start; i <= end; i++) {
|
|
item = items[i];
|
|
j = newIndices.get(item);
|
|
if (j !== void 0 && j !== -1) {
|
|
temp[j] = mapped[i];
|
|
tempdisposers[j] = disposers[i];
|
|
indexes && (tempIndexes[j] = indexes[i]);
|
|
j = newIndicesNext[j];
|
|
newIndices.set(item, j);
|
|
} else
|
|
disposers[i]();
|
|
}
|
|
for (j = start; j < newLen; j++) {
|
|
if (j in temp) {
|
|
mapped[j] = temp[j];
|
|
disposers[j] = tempdisposers[j];
|
|
if (indexes) {
|
|
indexes[j] = tempIndexes[j];
|
|
indexes[j](j);
|
|
}
|
|
} else
|
|
mapped[j] = createRoot(mapper);
|
|
}
|
|
mapped = mapped.slice(0, len = newLen);
|
|
items = newItems.slice(0);
|
|
}
|
|
return mapped;
|
|
});
|
|
function mapper(disposer) {
|
|
disposers[j] = disposer;
|
|
if (indexes) {
|
|
const [s, set] = createSignal(j);
|
|
indexes[j] = set;
|
|
return mapFn(newItems[j], s);
|
|
}
|
|
return mapFn(newItems[j]);
|
|
}
|
|
};
|
|
}
|
|
function indexArray(list, mapFn, options = {}) {
|
|
let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
|
|
onCleanup(() => dispose(disposers));
|
|
return () => {
|
|
const newItems = list() || [];
|
|
newItems[$TRACK];
|
|
return untrack(() => {
|
|
if (newItems.length === 0) {
|
|
if (len !== 0) {
|
|
dispose(disposers);
|
|
disposers = [];
|
|
items = [];
|
|
mapped = [];
|
|
len = 0;
|
|
signals = [];
|
|
}
|
|
if (options.fallback) {
|
|
items = [FALLBACK];
|
|
mapped[0] = createRoot((disposer) => {
|
|
disposers[0] = disposer;
|
|
return options.fallback();
|
|
});
|
|
len = 1;
|
|
}
|
|
return mapped;
|
|
}
|
|
if (items[0] === FALLBACK) {
|
|
disposers[0]();
|
|
disposers = [];
|
|
items = [];
|
|
mapped = [];
|
|
len = 0;
|
|
}
|
|
for (i = 0; i < newItems.length; i++) {
|
|
if (i < items.length && items[i] !== newItems[i]) {
|
|
signals[i](() => newItems[i]);
|
|
} else if (i >= items.length) {
|
|
mapped[i] = createRoot(mapper);
|
|
}
|
|
}
|
|
for (; i < items.length; i++) {
|
|
disposers[i]();
|
|
}
|
|
len = signals.length = disposers.length = newItems.length;
|
|
items = newItems.slice(0);
|
|
return mapped = mapped.slice(0, len);
|
|
});
|
|
function mapper(disposer) {
|
|
disposers[i] = disposer;
|
|
const [s, set] = createSignal(newItems[i]);
|
|
signals[i] = set;
|
|
return mapFn(s, i);
|
|
}
|
|
};
|
|
}
|
|
var hydrationEnabled = false;
|
|
function enableHydration() {
|
|
hydrationEnabled = true;
|
|
}
|
|
function createComponent(Comp, props) {
|
|
if (hydrationEnabled) {
|
|
if (sharedConfig.context) {
|
|
const c = sharedConfig.context;
|
|
setHydrateContext(nextHydrateContext());
|
|
const r = devComponent(Comp, props || {});
|
|
setHydrateContext(c);
|
|
return r;
|
|
}
|
|
}
|
|
return devComponent(Comp, props || {});
|
|
}
|
|
function trueFn() {
|
|
return true;
|
|
}
|
|
var propTraps = {
|
|
get(_, property, receiver) {
|
|
if (property === $PROXY)
|
|
return receiver;
|
|
return _.get(property);
|
|
},
|
|
has(_, property) {
|
|
return _.has(property);
|
|
},
|
|
set: trueFn,
|
|
deleteProperty: trueFn,
|
|
getOwnPropertyDescriptor(_, property) {
|
|
return {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get() {
|
|
return _.get(property);
|
|
},
|
|
set: trueFn,
|
|
deleteProperty: trueFn
|
|
};
|
|
},
|
|
ownKeys(_) {
|
|
return _.keys();
|
|
}
|
|
};
|
|
function resolveSource(s) {
|
|
return (s = typeof s === "function" ? s() : s) == null ? {} : s;
|
|
}
|
|
function mergeProps(...sources) {
|
|
return new Proxy({
|
|
get(property) {
|
|
for (let i = sources.length - 1; i >= 0; i--) {
|
|
const v = resolveSource(sources[i])[property];
|
|
if (v !== void 0)
|
|
return v;
|
|
}
|
|
},
|
|
has(property) {
|
|
for (let i = sources.length - 1; i >= 0; i--) {
|
|
if (property in resolveSource(sources[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
keys() {
|
|
const keys = [];
|
|
for (let i = 0; i < sources.length; i++)
|
|
keys.push(...Object.keys(resolveSource(sources[i])));
|
|
return [...new Set(keys)];
|
|
}
|
|
}, propTraps);
|
|
}
|
|
function splitProps(props, ...keys) {
|
|
const blocked = new Set(keys.flat());
|
|
const descriptors = Object.getOwnPropertyDescriptors(props);
|
|
const res = keys.map((k) => {
|
|
const clone = {};
|
|
for (let i = 0; i < k.length; i++) {
|
|
const key = k[i];
|
|
Object.defineProperty(clone, key, descriptors[key] ? descriptors[key] : {
|
|
get() {
|
|
return props[key];
|
|
},
|
|
set() {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
return clone;
|
|
});
|
|
res.push(new Proxy({
|
|
get(property) {
|
|
return blocked.has(property) ? void 0 : props[property];
|
|
},
|
|
has(property) {
|
|
return blocked.has(property) ? false : property in props;
|
|
},
|
|
keys() {
|
|
return Object.keys(props).filter((k) => !blocked.has(k));
|
|
}
|
|
}, propTraps));
|
|
return res;
|
|
}
|
|
function lazy(fn) {
|
|
let comp;
|
|
let p;
|
|
const wrap = (props) => {
|
|
const ctx = sharedConfig.context;
|
|
if (ctx) {
|
|
const [s, set] = createSignal();
|
|
(p || (p = fn())).then((mod) => {
|
|
setHydrateContext(ctx);
|
|
set(() => mod.default);
|
|
setHydrateContext();
|
|
});
|
|
comp = s;
|
|
} else if (!comp) {
|
|
const [s] = createResource(() => (p || (p = fn())).then((mod) => mod.default));
|
|
comp = s;
|
|
} else {
|
|
const c = comp();
|
|
if (c)
|
|
return c(props);
|
|
}
|
|
let Comp;
|
|
return createMemo(() => (Comp = comp()) && untrack(() => {
|
|
Object.assign(Comp, {
|
|
[$DEVCOMP]: true
|
|
});
|
|
if (!ctx)
|
|
return Comp(props);
|
|
const c = sharedConfig.context;
|
|
setHydrateContext(ctx);
|
|
const r = Comp(props);
|
|
setHydrateContext(c);
|
|
return r;
|
|
}));
|
|
};
|
|
wrap.preload = () => p || ((p = fn()).then((mod) => comp = () => mod.default), p);
|
|
return wrap;
|
|
}
|
|
var counter = 0;
|
|
function createUniqueId() {
|
|
const ctx = sharedConfig.context;
|
|
return ctx ? `${ctx.id}${ctx.count++}` : `cl-${counter++}`;
|
|
}
|
|
function For(props) {
|
|
const fallback = "fallback" in props && {
|
|
fallback: () => props.fallback
|
|
};
|
|
return createMemo(mapArray(() => props.each, props.children, fallback ? fallback : void 0));
|
|
}
|
|
function Index(props) {
|
|
const fallback = "fallback" in props && {
|
|
fallback: () => props.fallback
|
|
};
|
|
return createMemo(indexArray(() => props.each, props.children, fallback ? fallback : void 0));
|
|
}
|
|
function Show(props) {
|
|
let strictEqual = false;
|
|
const condition = createMemo(() => props.when, void 0, {
|
|
equals: (a, b) => strictEqual ? a === b : !a === !b
|
|
});
|
|
return createMemo(() => {
|
|
const c = condition();
|
|
if (c) {
|
|
const child = props.children;
|
|
return (strictEqual = typeof child === "function" && child.length > 0) ? untrack(() => child(c)) : child;
|
|
}
|
|
return props.fallback;
|
|
});
|
|
}
|
|
function Switch(props) {
|
|
let strictEqual = false;
|
|
const conditions = children(() => props.children), evalConditions = createMemo(() => {
|
|
let conds = conditions();
|
|
if (!Array.isArray(conds))
|
|
conds = [conds];
|
|
for (let i = 0; i < conds.length; i++) {
|
|
const c = conds[i].when;
|
|
if (c)
|
|
return [i, c, conds[i]];
|
|
}
|
|
return [-1];
|
|
}, void 0, {
|
|
equals: (a, b) => a[0] === b[0] && (strictEqual ? a[1] === b[1] : !a[1] === !b[1]) && a[2] === b[2]
|
|
});
|
|
return createMemo(() => {
|
|
const [index, when, cond] = evalConditions();
|
|
if (index < 0)
|
|
return props.fallback;
|
|
const c = cond.children;
|
|
return (strictEqual = typeof c === "function" && c.length > 0) ? untrack(() => c(when)) : c;
|
|
});
|
|
}
|
|
function Match(props) {
|
|
return props;
|
|
}
|
|
var Errors;
|
|
var NoErrors = {};
|
|
function resetErrorBoundaries() {
|
|
Errors && [...Errors].forEach((fn) => fn(NoErrors));
|
|
}
|
|
function ErrorBoundary(props) {
|
|
let err = NoErrors;
|
|
if (sharedConfig.context && sharedConfig.load) {
|
|
err = sharedConfig.load(sharedConfig.context.id + sharedConfig.context.count) || NoErrors;
|
|
}
|
|
const [errored, setErrored] = createSignal(err);
|
|
Errors || (Errors = /* @__PURE__ */ new Set());
|
|
Errors.add(setErrored);
|
|
onCleanup(() => Errors.delete(setErrored));
|
|
return createMemo(() => {
|
|
let e;
|
|
if ((e = errored()) !== NoErrors) {
|
|
const f = props.fallback;
|
|
if (typeof f !== "function" || f.length == 0)
|
|
console.error(e);
|
|
return typeof f === "function" && f.length ? untrack(() => f(e, () => setErrored(NoErrors))) : f;
|
|
}
|
|
onError(setErrored);
|
|
return props.children;
|
|
});
|
|
}
|
|
var SuspenseListContext = createContext();
|
|
function SuspenseList(props) {
|
|
let suspenseSetter, showContent, showFallback;
|
|
const listContext = useContext(SuspenseListContext);
|
|
if (listContext) {
|
|
const [inFallback, setFallback] = createSignal(false);
|
|
suspenseSetter = setFallback;
|
|
[showContent, showFallback] = listContext.register(inFallback);
|
|
}
|
|
const [registry, setRegistry] = createSignal([]), comp = createComponent(SuspenseListContext.Provider, {
|
|
value: {
|
|
register: (inFallback) => {
|
|
const [showingContent, showContent2] = createSignal(false), [showingFallback, showFallback2] = createSignal(false);
|
|
setRegistry((registry2) => [...registry2, {
|
|
inFallback,
|
|
showContent: showContent2,
|
|
showFallback: showFallback2
|
|
}]);
|
|
return [showingContent, showingFallback];
|
|
}
|
|
},
|
|
get children() {
|
|
return props.children;
|
|
}
|
|
});
|
|
createComputed(() => {
|
|
const reveal = props.revealOrder, tail = props.tail, visibleContent = showContent ? showContent() : true, visibleFallback = showFallback ? showFallback() : true, reg = registry(), reverse = reveal === "backwards";
|
|
if (reveal === "together") {
|
|
const all = reg.every((i) => !i.inFallback());
|
|
suspenseSetter && suspenseSetter(!all);
|
|
reg.forEach((i) => {
|
|
i.showContent(all && visibleContent);
|
|
i.showFallback(visibleFallback);
|
|
});
|
|
return;
|
|
}
|
|
let stop = false;
|
|
for (let i = 0, len = reg.length; i < len; i++) {
|
|
const n = reverse ? len - i - 1 : i, s = reg[n].inFallback();
|
|
if (!stop && !s) {
|
|
reg[n].showContent(visibleContent);
|
|
reg[n].showFallback(visibleFallback);
|
|
} else {
|
|
const next = !stop;
|
|
if (next && suspenseSetter)
|
|
suspenseSetter(true);
|
|
if (!tail || next && tail === "collapsed") {
|
|
reg[n].showFallback(visibleFallback);
|
|
} else
|
|
reg[n].showFallback(false);
|
|
stop = true;
|
|
reg[n].showContent(next);
|
|
}
|
|
}
|
|
if (!stop && suspenseSetter)
|
|
suspenseSetter(false);
|
|
});
|
|
return comp;
|
|
}
|
|
function Suspense(props) {
|
|
let counter2 = 0, showContent, showFallback, ctx, p, flicker, error;
|
|
const [inFallback, setFallback] = createSignal(false), SuspenseContext2 = getSuspenseContext(), store = {
|
|
increment: () => {
|
|
if (++counter2 === 1)
|
|
setFallback(true);
|
|
},
|
|
decrement: () => {
|
|
if (--counter2 === 0)
|
|
setFallback(false);
|
|
},
|
|
inFallback,
|
|
effects: [],
|
|
resolved: false
|
|
}, owner = getOwner();
|
|
if (sharedConfig.context && sharedConfig.load) {
|
|
const key = sharedConfig.context.id + sharedConfig.context.count;
|
|
p = sharedConfig.load(key);
|
|
if (p) {
|
|
if (typeof p !== "object" || !("then" in p))
|
|
p = Promise.resolve(p);
|
|
const [s, set] = createSignal(void 0, {
|
|
equals: false
|
|
});
|
|
flicker = s;
|
|
p.then((err) => {
|
|
if ((error = err) || sharedConfig.done)
|
|
return set();
|
|
sharedConfig.gather(key);
|
|
setHydrateContext(ctx);
|
|
set();
|
|
setHydrateContext();
|
|
});
|
|
} else if (p === null)
|
|
sharedConfig.gather(key);
|
|
}
|
|
const listContext = useContext(SuspenseListContext);
|
|
if (listContext)
|
|
[showContent, showFallback] = listContext.register(store.inFallback);
|
|
let dispose2;
|
|
onCleanup(() => dispose2 && dispose2());
|
|
return createComponent(SuspenseContext2.Provider, {
|
|
value: store,
|
|
get children() {
|
|
return createMemo(() => {
|
|
if (error)
|
|
throw error;
|
|
ctx = sharedConfig.context;
|
|
if (flicker) {
|
|
flicker();
|
|
return flicker = void 0;
|
|
}
|
|
if (ctx && p === void 0)
|
|
setHydrateContext();
|
|
const rendered = createMemo(() => props.children);
|
|
return createMemo(() => {
|
|
const inFallback2 = store.inFallback(), visibleContent = showContent ? showContent() : true, visibleFallback = showFallback ? showFallback() : true;
|
|
dispose2 && dispose2();
|
|
if ((!inFallback2 || p !== void 0) && visibleContent) {
|
|
store.resolved = true;
|
|
ctx = p = void 0;
|
|
resumeEffects(store.effects);
|
|
return rendered();
|
|
}
|
|
if (!visibleFallback)
|
|
return;
|
|
return createRoot((disposer) => {
|
|
dispose2 = disposer;
|
|
if (ctx) {
|
|
setHydrateContext({
|
|
id: ctx.id + "f",
|
|
count: 0
|
|
});
|
|
ctx = void 0;
|
|
}
|
|
return props.fallback;
|
|
}, owner);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
var DEV;
|
|
{
|
|
DEV = {
|
|
writeSignal,
|
|
serializeGraph,
|
|
registerGraph,
|
|
hashValue
|
|
};
|
|
}
|
|
if (globalThis) {
|
|
if (!globalThis.Solid$$)
|
|
globalThis.Solid$$ = true;
|
|
else
|
|
console.warn("You appear to have multiple instances of Solid. This can lead to unexpected behavior.");
|
|
}
|
|
|
|
export {
|
|
requestCallback,
|
|
cancelCallback,
|
|
sharedConfig,
|
|
equalFn,
|
|
$PROXY,
|
|
$TRACK,
|
|
$DEVCOMP,
|
|
createRoot,
|
|
createSignal,
|
|
createComputed,
|
|
createRenderEffect,
|
|
createEffect,
|
|
createReaction,
|
|
createMemo,
|
|
createResource,
|
|
createDeferred,
|
|
createSelector,
|
|
batch,
|
|
untrack,
|
|
on,
|
|
onMount,
|
|
onCleanup,
|
|
onError,
|
|
getListener,
|
|
getOwner,
|
|
runWithOwner,
|
|
enableScheduling,
|
|
startTransition,
|
|
useTransition,
|
|
createContext,
|
|
useContext,
|
|
children,
|
|
enableExternalSource,
|
|
observable,
|
|
from,
|
|
mapArray,
|
|
indexArray,
|
|
enableHydration,
|
|
createComponent,
|
|
mergeProps,
|
|
splitProps,
|
|
lazy,
|
|
createUniqueId,
|
|
For,
|
|
Index,
|
|
Show,
|
|
Switch,
|
|
Match,
|
|
resetErrorBoundaries,
|
|
ErrorBoundary,
|
|
SuspenseList,
|
|
Suspense,
|
|
DEV
|
|
};
|
|
//# sourceMappingURL=chunk-R2HWYFCB.js.map
|