Add js web stuff to landing page + documentation
This commit is contained in:
485
go/jsruntime/runtime/solid-js/store/dist/dev.cjs
vendored
Normal file
485
go/jsruntime/runtime/solid-js/store/dist/dev.cjs
vendored
Normal file
@@ -0,0 +1,485 @@
|
||||
'use strict';
|
||||
|
||||
var solidJs = require('solid-js');
|
||||
|
||||
const $RAW = Symbol("store-raw"),
|
||||
$NODE = Symbol("store-node"),
|
||||
$HAS = Symbol("store-has"),
|
||||
$SELF = Symbol("store-self");
|
||||
const DevHooks = {
|
||||
onStoreNodeUpdate: null
|
||||
};
|
||||
function wrap$1(value) {
|
||||
let p = value[solidJs.$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, solidJs.$PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps$1)
|
||||
});
|
||||
if (!Array.isArray(value)) {
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value),
|
||||
proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(proto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
Object.defineProperty(value, prop, {
|
||||
configurable: true,
|
||||
enumerable: desc[prop].enumerable,
|
||||
get: desc[prop].get.bind(p)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function isWrappable(obj) {
|
||||
let proto;
|
||||
return obj != null && typeof obj === "object" && (obj[solidJs.$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item, set = new Set()) {
|
||||
let result, unwrapped, v, prop;
|
||||
if (result = item != null && item[$RAW]) return result;
|
||||
if (!isWrappable(item) || set.has(item)) return item;
|
||||
if (Array.isArray(item)) {
|
||||
if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
|
||||
for (let i = 0, l = item.length; i < l; i++) {
|
||||
v = item[i];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
|
||||
}
|
||||
} else {
|
||||
if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
|
||||
const keys = Object.keys(item),
|
||||
desc = Object.getOwnPropertyDescriptors(item);
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
prop = keys[i];
|
||||
if (desc[prop].get) continue;
|
||||
v = item[prop];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
function getNodes(target, symbol) {
|
||||
let nodes = target[symbol];
|
||||
if (!nodes) Object.defineProperty(target, symbol, {
|
||||
value: nodes = Object.create(null)
|
||||
});
|
||||
return nodes;
|
||||
}
|
||||
function getNode(nodes, property, value) {
|
||||
if (nodes[property]) return nodes[property];
|
||||
const [s, set] = solidJs.createSignal(value, {
|
||||
equals: false,
|
||||
internal: true
|
||||
});
|
||||
s.$ = set;
|
||||
return nodes[property] = s;
|
||||
}
|
||||
function proxyDescriptor$1(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[solidJs.$PROXY][property];
|
||||
return desc;
|
||||
}
|
||||
function trackSelf(target) {
|
||||
solidJs.getListener() && getNode(getNodes(target, $NODE), $SELF)();
|
||||
}
|
||||
function ownKeys(target) {
|
||||
trackSelf(target);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const proxyTraps$1 = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === solidJs.$PROXY) return receiver;
|
||||
if (property === solidJs.$TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
if (solidJs.getListener() && (typeof value !== "function" || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
|
||||
}
|
||||
return isWrappable(value) ? wrap$1(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set() {
|
||||
console.warn("Cannot mutate a Store directly");
|
||||
return true;
|
||||
},
|
||||
deleteProperty() {
|
||||
console.warn("Cannot mutate a Store directly");
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor$1
|
||||
};
|
||||
function setProperty(state, property, value, deleting = false) {
|
||||
if (property === "__proto__") {
|
||||
console.warn(`Refusing to set "__proto__" on a store.`);
|
||||
return;
|
||||
}
|
||||
if (!deleting && state[property] === value) return;
|
||||
const prev = state[property],
|
||||
len = state.length;
|
||||
DevHooks.onStoreNodeUpdate && DevHooks.onStoreNodeUpdate(state, property, value, prev);
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
|
||||
} else {
|
||||
state[property] = value;
|
||||
if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
|
||||
}
|
||||
let nodes = getNodes(state, $NODE),
|
||||
node;
|
||||
if (node = getNode(nodes, property, prev)) node.$(() => value);
|
||||
if (Array.isArray(state) && state.length !== len) {
|
||||
for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
|
||||
(node = getNode(nodes, "length", len)) && node.$(state.length);
|
||||
}
|
||||
(node = nodes[$SELF]) && node.$();
|
||||
}
|
||||
function mergeStoreNode(state, value) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey$1(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey$1(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
next = unwrap(next);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
prev = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey$1(part))) {
|
||||
console.warn(`Refusing to traverse unsafe key "${part}" on a store.`);
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
prev = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(prev, traversed);
|
||||
if (value === prev) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
value = unwrap(value);
|
||||
if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(prev, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(...[store, options]) {
|
||||
const unwrappedStore = unwrap(store || {});
|
||||
const isArray = Array.isArray(unwrappedStore);
|
||||
if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createStore'. Expected an object.`);
|
||||
const wrappedStore = wrap$1(unwrappedStore);
|
||||
solidJs.DEV.registerGraph({
|
||||
value: unwrappedStore,
|
||||
name: options && options.name
|
||||
});
|
||||
function setStore(...args) {
|
||||
solidJs.batch(() => {
|
||||
isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
|
||||
});
|
||||
}
|
||||
return [wrappedStore, setStore];
|
||||
}
|
||||
|
||||
function proxyDescriptor(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || desc.set || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[solidJs.$PROXY][property];
|
||||
desc.set = v => target[solidJs.$PROXY][property] = v;
|
||||
return desc;
|
||||
}
|
||||
const proxyTraps = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === solidJs.$PROXY) return receiver;
|
||||
if (property === solidJs.$TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
const isFunction = typeof value === "function";
|
||||
if (solidJs.getListener() && (!isFunction || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
|
||||
return (...args) => solidJs.batch(() => Array.prototype[property].apply(receiver, args));
|
||||
}
|
||||
}
|
||||
return isWrappable(value) ? wrap(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set(target, property, value) {
|
||||
solidJs.batch(() => setProperty(target, property, unwrap(value)));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
solidJs.batch(() => setProperty(target, property, undefined, true));
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor
|
||||
};
|
||||
function wrap(value) {
|
||||
let p = value[solidJs.$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, solidJs.$PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps)
|
||||
});
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value);
|
||||
const proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
let curProto = proto;
|
||||
while (curProto != null) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(curProto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
curProto = Object.getPrototypeOf(curProto);
|
||||
}
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
const get = desc[prop].get.bind(p);
|
||||
Object.defineProperty(value, prop, {
|
||||
get,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (desc[prop].set) {
|
||||
const og = desc[prop].set,
|
||||
set = v => solidJs.batch(() => og.call(p, v));
|
||||
Object.defineProperty(value, prop, {
|
||||
set,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function createMutable(state, options) {
|
||||
const unwrappedStore = unwrap(state || {});
|
||||
if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createMutable'. Expected an object.`);
|
||||
const wrappedStore = wrap(unwrappedStore);
|
||||
solidJs.DEV.registerGraph({
|
||||
value: unwrappedStore,
|
||||
name: options && options.name
|
||||
});
|
||||
return wrappedStore;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
solidJs.batch(() => modifier(unwrap(state)));
|
||||
}
|
||||
|
||||
const $ROOT = Symbol("store-root");
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function applyState(target, parent, property, merge, key) {
|
||||
if (isUnsafeKey(property)) return;
|
||||
const previous = parent[property];
|
||||
if (target === previous) return;
|
||||
const isArray = Array.isArray(target);
|
||||
if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
|
||||
setProperty(parent, property, target);
|
||||
return;
|
||||
}
|
||||
if (isArray) {
|
||||
if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
|
||||
let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
|
||||
for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
|
||||
applyState(target[start], previous, start, merge, key);
|
||||
}
|
||||
const temp = new Array(target.length),
|
||||
newIndices = new Map();
|
||||
for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
|
||||
temp[newEnd] = previous[end];
|
||||
}
|
||||
if (start > newEnd || start > end) {
|
||||
for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
|
||||
for (; j < target.length; j++) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
newIndicesNext = new Array(newEnd + 1);
|
||||
for (j = newEnd; j >= start; j--) {
|
||||
item = target[j];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
i = newIndices.get(keyVal);
|
||||
newIndicesNext[j] = i === undefined ? -1 : i;
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
for (i = start; i <= end; i++) {
|
||||
item = previous[i];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
j = newIndices.get(keyVal);
|
||||
if (j !== undefined && j !== -1) {
|
||||
temp[j] = previous[i];
|
||||
j = newIndicesNext[j];
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
}
|
||||
for (j = start; j < target.length; j++) {
|
||||
if (j in temp) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
} else setProperty(previous, j, target[j]);
|
||||
}
|
||||
} else {
|
||||
for (let i = 0, len = target.length; i < len; i++) {
|
||||
applyState(target[i], previous, i, merge, key);
|
||||
}
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
const targetKeys = Object.keys(target);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
if (isUnsafeKey(targetKeys[i])) continue;
|
||||
applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
|
||||
}
|
||||
const previousKeys = Object.keys(previous);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
|
||||
}
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
const {
|
||||
merge,
|
||||
key = "id"
|
||||
} = options,
|
||||
v = unwrap(value);
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(v)) return v;
|
||||
const res = applyState(v, {
|
||||
[$ROOT]: state
|
||||
}, $ROOT, merge, key);
|
||||
return res === undefined ? state : res;
|
||||
};
|
||||
}
|
||||
const producers = new WeakMap();
|
||||
const setterTraps = {
|
||||
get(target, property) {
|
||||
if (property === $RAW) return target;
|
||||
const value = target[property];
|
||||
if (property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
let proxy;
|
||||
return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
|
||||
},
|
||||
set(target, property, value) {
|
||||
setProperty(target, property, unwrap(value));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
setProperty(target, property, undefined, true);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) {
|
||||
let proxy;
|
||||
if (!(proxy = producers.get(state))) {
|
||||
producers.set(state, proxy = new Proxy(state, setterTraps));
|
||||
}
|
||||
fn(proxy);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
|
||||
const DEV = {
|
||||
$NODE,
|
||||
isWrappable,
|
||||
hooks: DevHooks
|
||||
} ;
|
||||
|
||||
exports.$RAW = $RAW;
|
||||
exports.DEV = DEV;
|
||||
exports.createMutable = createMutable;
|
||||
exports.createStore = createStore;
|
||||
exports.modifyMutable = modifyMutable;
|
||||
exports.produce = produce;
|
||||
exports.reconcile = reconcile;
|
||||
exports.unwrap = unwrap;
|
||||
476
go/jsruntime/runtime/solid-js/store/dist/dev.js
vendored
Normal file
476
go/jsruntime/runtime/solid-js/store/dist/dev.js
vendored
Normal file
@@ -0,0 +1,476 @@
|
||||
import { $PROXY, DEV as DEV$1, batch, $TRACK, getListener, createSignal } from 'solid-js';
|
||||
|
||||
const $RAW = Symbol("store-raw"),
|
||||
$NODE = Symbol("store-node"),
|
||||
$HAS = Symbol("store-has"),
|
||||
$SELF = Symbol("store-self");
|
||||
const DevHooks = {
|
||||
onStoreNodeUpdate: null
|
||||
};
|
||||
function wrap$1(value) {
|
||||
let p = value[$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, $PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps$1)
|
||||
});
|
||||
if (!Array.isArray(value)) {
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value),
|
||||
proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(proto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
Object.defineProperty(value, prop, {
|
||||
configurable: true,
|
||||
enumerable: desc[prop].enumerable,
|
||||
get: desc[prop].get.bind(p)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function isWrappable(obj) {
|
||||
let proto;
|
||||
return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item, set = new Set()) {
|
||||
let result, unwrapped, v, prop;
|
||||
if (result = item != null && item[$RAW]) return result;
|
||||
if (!isWrappable(item) || set.has(item)) return item;
|
||||
if (Array.isArray(item)) {
|
||||
if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
|
||||
for (let i = 0, l = item.length; i < l; i++) {
|
||||
v = item[i];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
|
||||
}
|
||||
} else {
|
||||
if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
|
||||
const keys = Object.keys(item),
|
||||
desc = Object.getOwnPropertyDescriptors(item);
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
prop = keys[i];
|
||||
if (desc[prop].get) continue;
|
||||
v = item[prop];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
function getNodes(target, symbol) {
|
||||
let nodes = target[symbol];
|
||||
if (!nodes) Object.defineProperty(target, symbol, {
|
||||
value: nodes = Object.create(null)
|
||||
});
|
||||
return nodes;
|
||||
}
|
||||
function getNode(nodes, property, value) {
|
||||
if (nodes[property]) return nodes[property];
|
||||
const [s, set] = createSignal(value, {
|
||||
equals: false,
|
||||
internal: true
|
||||
});
|
||||
s.$ = set;
|
||||
return nodes[property] = s;
|
||||
}
|
||||
function proxyDescriptor$1(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[$PROXY][property];
|
||||
return desc;
|
||||
}
|
||||
function trackSelf(target) {
|
||||
getListener() && getNode(getNodes(target, $NODE), $SELF)();
|
||||
}
|
||||
function ownKeys(target) {
|
||||
trackSelf(target);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const proxyTraps$1 = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === $PROXY) return receiver;
|
||||
if (property === $TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
if (getListener() && (typeof value !== "function" || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
|
||||
}
|
||||
return isWrappable(value) ? wrap$1(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set() {
|
||||
console.warn("Cannot mutate a Store directly");
|
||||
return true;
|
||||
},
|
||||
deleteProperty() {
|
||||
console.warn("Cannot mutate a Store directly");
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor$1
|
||||
};
|
||||
function setProperty(state, property, value, deleting = false) {
|
||||
if (property === "__proto__") {
|
||||
console.warn(`Refusing to set "__proto__" on a store.`);
|
||||
return;
|
||||
}
|
||||
if (!deleting && state[property] === value) return;
|
||||
const prev = state[property],
|
||||
len = state.length;
|
||||
DevHooks.onStoreNodeUpdate && DevHooks.onStoreNodeUpdate(state, property, value, prev);
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
|
||||
} else {
|
||||
state[property] = value;
|
||||
if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
|
||||
}
|
||||
let nodes = getNodes(state, $NODE),
|
||||
node;
|
||||
if (node = getNode(nodes, property, prev)) node.$(() => value);
|
||||
if (Array.isArray(state) && state.length !== len) {
|
||||
for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
|
||||
(node = getNode(nodes, "length", len)) && node.$(state.length);
|
||||
}
|
||||
(node = nodes[$SELF]) && node.$();
|
||||
}
|
||||
function mergeStoreNode(state, value) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey$1(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey$1(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
next = unwrap(next);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
prev = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey$1(part))) {
|
||||
console.warn(`Refusing to traverse unsafe key "${part}" on a store.`);
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
prev = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(prev, traversed);
|
||||
if (value === prev) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
value = unwrap(value);
|
||||
if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(prev, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(...[store, options]) {
|
||||
const unwrappedStore = unwrap(store || {});
|
||||
const isArray = Array.isArray(unwrappedStore);
|
||||
if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createStore'. Expected an object.`);
|
||||
const wrappedStore = wrap$1(unwrappedStore);
|
||||
DEV$1.registerGraph({
|
||||
value: unwrappedStore,
|
||||
name: options && options.name
|
||||
});
|
||||
function setStore(...args) {
|
||||
batch(() => {
|
||||
isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
|
||||
});
|
||||
}
|
||||
return [wrappedStore, setStore];
|
||||
}
|
||||
|
||||
function proxyDescriptor(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[$PROXY][property];
|
||||
desc.set = v => target[$PROXY][property] = v;
|
||||
return desc;
|
||||
}
|
||||
const proxyTraps = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === $PROXY) return receiver;
|
||||
if (property === $TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
const isFunction = typeof value === "function";
|
||||
if (getListener() && (!isFunction || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
|
||||
return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
|
||||
}
|
||||
}
|
||||
return isWrappable(value) ? wrap(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set(target, property, value) {
|
||||
batch(() => setProperty(target, property, unwrap(value)));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
batch(() => setProperty(target, property, undefined, true));
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor
|
||||
};
|
||||
function wrap(value) {
|
||||
let p = value[$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, $PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps)
|
||||
});
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value);
|
||||
const proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
let curProto = proto;
|
||||
while (curProto != null) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(curProto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
curProto = Object.getPrototypeOf(curProto);
|
||||
}
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
const get = desc[prop].get.bind(p);
|
||||
Object.defineProperty(value, prop, {
|
||||
get,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (desc[prop].set) {
|
||||
const og = desc[prop].set,
|
||||
set = v => batch(() => og.call(p, v));
|
||||
Object.defineProperty(value, prop, {
|
||||
set,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function createMutable(state, options) {
|
||||
const unwrappedStore = unwrap(state || {});
|
||||
if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createMutable'. Expected an object.`);
|
||||
const wrappedStore = wrap(unwrappedStore);
|
||||
DEV$1.registerGraph({
|
||||
value: unwrappedStore,
|
||||
name: options && options.name
|
||||
});
|
||||
return wrappedStore;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
batch(() => modifier(unwrap(state)));
|
||||
}
|
||||
|
||||
const $ROOT = Symbol("store-root");
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function applyState(target, parent, property, merge, key) {
|
||||
if (isUnsafeKey(property)) return;
|
||||
const previous = parent[property];
|
||||
if (target === previous) return;
|
||||
const isArray = Array.isArray(target);
|
||||
if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
|
||||
setProperty(parent, property, target);
|
||||
return;
|
||||
}
|
||||
if (isArray) {
|
||||
if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
|
||||
let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
|
||||
for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
|
||||
applyState(target[start], previous, start, merge, key);
|
||||
}
|
||||
const temp = new Array(target.length),
|
||||
newIndices = new Map();
|
||||
for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
|
||||
temp[newEnd] = previous[end];
|
||||
}
|
||||
if (start > newEnd || start > end) {
|
||||
for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
|
||||
for (; j < target.length; j++) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
newIndicesNext = new Array(newEnd + 1);
|
||||
for (j = newEnd; j >= start; j--) {
|
||||
item = target[j];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
i = newIndices.get(keyVal);
|
||||
newIndicesNext[j] = i === undefined ? -1 : i;
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
for (i = start; i <= end; i++) {
|
||||
item = previous[i];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
j = newIndices.get(keyVal);
|
||||
if (j !== undefined && j !== -1) {
|
||||
temp[j] = previous[i];
|
||||
j = newIndicesNext[j];
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
}
|
||||
for (j = start; j < target.length; j++) {
|
||||
if (j in temp) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
} else setProperty(previous, j, target[j]);
|
||||
}
|
||||
} else {
|
||||
for (let i = 0, len = target.length; i < len; i++) {
|
||||
applyState(target[i], previous, i, merge, key);
|
||||
}
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
const targetKeys = Object.keys(target);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
if (isUnsafeKey(targetKeys[i])) continue;
|
||||
applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
|
||||
}
|
||||
const previousKeys = Object.keys(previous);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
|
||||
}
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
const {
|
||||
merge,
|
||||
key = "id"
|
||||
} = options,
|
||||
v = unwrap(value);
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(v)) return v;
|
||||
const res = applyState(v, {
|
||||
[$ROOT]: state
|
||||
}, $ROOT, merge, key);
|
||||
return res === undefined ? state : res;
|
||||
};
|
||||
}
|
||||
const producers = new WeakMap();
|
||||
const setterTraps = {
|
||||
get(target, property) {
|
||||
if (property === $RAW) return target;
|
||||
const value = target[property];
|
||||
if (property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
let proxy;
|
||||
return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
|
||||
},
|
||||
set(target, property, value) {
|
||||
setProperty(target, property, unwrap(value));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
setProperty(target, property, undefined, true);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) {
|
||||
let proxy;
|
||||
if (!(proxy = producers.get(state))) {
|
||||
producers.set(state, proxy = new Proxy(state, setterTraps));
|
||||
}
|
||||
fn(proxy);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
|
||||
const DEV = {
|
||||
$NODE,
|
||||
isWrappable,
|
||||
hooks: DevHooks
|
||||
} ;
|
||||
|
||||
export { $RAW, DEV, createMutable, createStore, modifyMutable, produce, reconcile, unwrap };
|
||||
133
go/jsruntime/runtime/solid-js/store/dist/server.cjs
vendored
Normal file
133
go/jsruntime/runtime/solid-js/store/dist/server.cjs
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
'use strict';
|
||||
|
||||
const $RAW = Symbol("state-raw");
|
||||
function isWrappable(obj) {
|
||||
return obj != null && typeof obj === "object" && (Object.getPrototypeOf(obj) === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item) {
|
||||
return item;
|
||||
}
|
||||
function setProperty(state, property, value, force) {
|
||||
if (property === "__proto__") return;
|
||||
if (!force && state[property] === value) return;
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
} else state[property] = value;
|
||||
}
|
||||
function mergeStoreNode(state, value, force) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey(key)) continue;
|
||||
setProperty(state, key, value[key], force);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
next = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey(part))) return;
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
next = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(next, traversed);
|
||||
if (value === next) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(next, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(state) {
|
||||
const isArray = Array.isArray(state);
|
||||
function setStore(...args) {
|
||||
isArray && args.length === 1 ? updateArray(state, args[0]) : updatePath(state, args);
|
||||
}
|
||||
return [state, setStore];
|
||||
}
|
||||
function createMutable(state) {
|
||||
return state;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
modifier(state);
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(value)) return value;
|
||||
const targetKeys = Object.keys(value);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
const key = targetKeys[i];
|
||||
if (isUnsafeKey(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
const previousKeys = Object.keys(state);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) fn(state);
|
||||
return state;
|
||||
};
|
||||
}
|
||||
const DEV = undefined;
|
||||
|
||||
exports.$RAW = $RAW;
|
||||
exports.DEV = DEV;
|
||||
exports.createMutable = createMutable;
|
||||
exports.createStore = createStore;
|
||||
exports.isWrappable = isWrappable;
|
||||
exports.modifyMutable = modifyMutable;
|
||||
exports.produce = produce;
|
||||
exports.reconcile = reconcile;
|
||||
exports.setProperty = setProperty;
|
||||
exports.unwrap = unwrap;
|
||||
exports.updatePath = updatePath;
|
||||
121
go/jsruntime/runtime/solid-js/store/dist/server.js
vendored
Normal file
121
go/jsruntime/runtime/solid-js/store/dist/server.js
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
const $RAW = Symbol("state-raw");
|
||||
function isWrappable(obj) {
|
||||
return obj != null && typeof obj === "object" && (Object.getPrototypeOf(obj) === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item) {
|
||||
return item;
|
||||
}
|
||||
function setProperty(state, property, value, force) {
|
||||
if (property === "__proto__") return;
|
||||
if (!force && state[property] === value) return;
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
} else state[property] = value;
|
||||
}
|
||||
function mergeStoreNode(state, value, force) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey(key)) continue;
|
||||
setProperty(state, key, value[key], force);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
next = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey(part))) return;
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
next = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(next, traversed);
|
||||
if (value === next) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(next, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(state) {
|
||||
const isArray = Array.isArray(state);
|
||||
function setStore(...args) {
|
||||
isArray && args.length === 1 ? updateArray(state, args[0]) : updatePath(state, args);
|
||||
}
|
||||
return [state, setStore];
|
||||
}
|
||||
function createMutable(state) {
|
||||
return state;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
modifier(state);
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(value)) return value;
|
||||
const targetKeys = Object.keys(value);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
const key = targetKeys[i];
|
||||
if (isUnsafeKey(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
const previousKeys = Object.keys(state);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) fn(state);
|
||||
return state;
|
||||
};
|
||||
}
|
||||
const DEV = undefined;
|
||||
|
||||
export { $RAW, DEV, createMutable, createStore, isWrappable, modifyMutable, produce, reconcile, setProperty, unwrap, updatePath };
|
||||
463
go/jsruntime/runtime/solid-js/store/dist/store.cjs
vendored
Normal file
463
go/jsruntime/runtime/solid-js/store/dist/store.cjs
vendored
Normal file
@@ -0,0 +1,463 @@
|
||||
'use strict';
|
||||
|
||||
var solidJs = require('solid-js');
|
||||
|
||||
const $RAW = Symbol("store-raw"),
|
||||
$NODE = Symbol("store-node"),
|
||||
$HAS = Symbol("store-has"),
|
||||
$SELF = Symbol("store-self");
|
||||
function wrap$1(value) {
|
||||
let p = value[solidJs.$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, solidJs.$PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps$1)
|
||||
});
|
||||
if (!Array.isArray(value)) {
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value),
|
||||
proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(proto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
Object.defineProperty(value, prop, {
|
||||
configurable: true,
|
||||
enumerable: desc[prop].enumerable,
|
||||
get: desc[prop].get.bind(p)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function isWrappable(obj) {
|
||||
let proto;
|
||||
return obj != null && typeof obj === "object" && (obj[solidJs.$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item, set = new Set()) {
|
||||
let result, unwrapped, v, prop;
|
||||
if (result = item != null && item[$RAW]) return result;
|
||||
if (!isWrappable(item) || set.has(item)) return item;
|
||||
if (Array.isArray(item)) {
|
||||
if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
|
||||
for (let i = 0, l = item.length; i < l; i++) {
|
||||
v = item[i];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
|
||||
}
|
||||
} else {
|
||||
if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
|
||||
const keys = Object.keys(item),
|
||||
desc = Object.getOwnPropertyDescriptors(item);
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
prop = keys[i];
|
||||
if (desc[prop].get) continue;
|
||||
v = item[prop];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
function getNodes(target, symbol) {
|
||||
let nodes = target[symbol];
|
||||
if (!nodes) Object.defineProperty(target, symbol, {
|
||||
value: nodes = Object.create(null)
|
||||
});
|
||||
return nodes;
|
||||
}
|
||||
function getNode(nodes, property, value) {
|
||||
if (nodes[property]) return nodes[property];
|
||||
const [s, set] = solidJs.createSignal(value, {
|
||||
equals: false,
|
||||
internal: true
|
||||
});
|
||||
s.$ = set;
|
||||
return nodes[property] = s;
|
||||
}
|
||||
function proxyDescriptor$1(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[solidJs.$PROXY][property];
|
||||
return desc;
|
||||
}
|
||||
function trackSelf(target) {
|
||||
solidJs.getListener() && getNode(getNodes(target, $NODE), $SELF)();
|
||||
}
|
||||
function ownKeys(target) {
|
||||
trackSelf(target);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const proxyTraps$1 = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === solidJs.$PROXY) return receiver;
|
||||
if (property === solidJs.$TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
if (solidJs.getListener() && (typeof value !== "function" || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
|
||||
}
|
||||
return isWrappable(value) ? wrap$1(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set() {
|
||||
return true;
|
||||
},
|
||||
deleteProperty() {
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor$1
|
||||
};
|
||||
function setProperty(state, property, value, deleting = false) {
|
||||
if (property === "__proto__") {
|
||||
return;
|
||||
}
|
||||
if (!deleting && state[property] === value) return;
|
||||
const prev = state[property],
|
||||
len = state.length;
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
|
||||
} else {
|
||||
state[property] = value;
|
||||
if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
|
||||
}
|
||||
let nodes = getNodes(state, $NODE),
|
||||
node;
|
||||
if (node = getNode(nodes, property, prev)) node.$(() => value);
|
||||
if (Array.isArray(state) && state.length !== len) {
|
||||
for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
|
||||
(node = getNode(nodes, "length", len)) && node.$(state.length);
|
||||
}
|
||||
(node = nodes[$SELF]) && node.$();
|
||||
}
|
||||
function mergeStoreNode(state, value) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey$1(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey$1(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
next = unwrap(next);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
prev = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey$1(part))) {
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
prev = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(prev, traversed);
|
||||
if (value === prev) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
value = unwrap(value);
|
||||
if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(prev, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(...[store, options]) {
|
||||
const unwrappedStore = unwrap(store || {});
|
||||
const isArray = Array.isArray(unwrappedStore);
|
||||
const wrappedStore = wrap$1(unwrappedStore);
|
||||
function setStore(...args) {
|
||||
solidJs.batch(() => {
|
||||
isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
|
||||
});
|
||||
}
|
||||
return [wrappedStore, setStore];
|
||||
}
|
||||
|
||||
function proxyDescriptor(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || desc.set || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[solidJs.$PROXY][property];
|
||||
desc.set = v => target[solidJs.$PROXY][property] = v;
|
||||
return desc;
|
||||
}
|
||||
const proxyTraps = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === solidJs.$PROXY) return receiver;
|
||||
if (property === solidJs.$TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
const isFunction = typeof value === "function";
|
||||
if (solidJs.getListener() && (!isFunction || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
|
||||
return (...args) => solidJs.batch(() => Array.prototype[property].apply(receiver, args));
|
||||
}
|
||||
}
|
||||
return isWrappable(value) ? wrap(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set(target, property, value) {
|
||||
solidJs.batch(() => setProperty(target, property, unwrap(value)));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
solidJs.batch(() => setProperty(target, property, undefined, true));
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor
|
||||
};
|
||||
function wrap(value) {
|
||||
let p = value[solidJs.$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, solidJs.$PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps)
|
||||
});
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value);
|
||||
const proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
let curProto = proto;
|
||||
while (curProto != null) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(curProto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
curProto = Object.getPrototypeOf(curProto);
|
||||
}
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
const get = desc[prop].get.bind(p);
|
||||
Object.defineProperty(value, prop, {
|
||||
get,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (desc[prop].set) {
|
||||
const og = desc[prop].set,
|
||||
set = v => solidJs.batch(() => og.call(p, v));
|
||||
Object.defineProperty(value, prop, {
|
||||
set,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function createMutable(state, options) {
|
||||
const unwrappedStore = unwrap(state || {});
|
||||
const wrappedStore = wrap(unwrappedStore);
|
||||
return wrappedStore;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
solidJs.batch(() => modifier(unwrap(state)));
|
||||
}
|
||||
|
||||
const $ROOT = Symbol("store-root");
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function applyState(target, parent, property, merge, key) {
|
||||
if (isUnsafeKey(property)) return;
|
||||
const previous = parent[property];
|
||||
if (target === previous) return;
|
||||
const isArray = Array.isArray(target);
|
||||
if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
|
||||
setProperty(parent, property, target);
|
||||
return;
|
||||
}
|
||||
if (isArray) {
|
||||
if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
|
||||
let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
|
||||
for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
|
||||
applyState(target[start], previous, start, merge, key);
|
||||
}
|
||||
const temp = new Array(target.length),
|
||||
newIndices = new Map();
|
||||
for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
|
||||
temp[newEnd] = previous[end];
|
||||
}
|
||||
if (start > newEnd || start > end) {
|
||||
for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
|
||||
for (; j < target.length; j++) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
newIndicesNext = new Array(newEnd + 1);
|
||||
for (j = newEnd; j >= start; j--) {
|
||||
item = target[j];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
i = newIndices.get(keyVal);
|
||||
newIndicesNext[j] = i === undefined ? -1 : i;
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
for (i = start; i <= end; i++) {
|
||||
item = previous[i];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
j = newIndices.get(keyVal);
|
||||
if (j !== undefined && j !== -1) {
|
||||
temp[j] = previous[i];
|
||||
j = newIndicesNext[j];
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
}
|
||||
for (j = start; j < target.length; j++) {
|
||||
if (j in temp) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
} else setProperty(previous, j, target[j]);
|
||||
}
|
||||
} else {
|
||||
for (let i = 0, len = target.length; i < len; i++) {
|
||||
applyState(target[i], previous, i, merge, key);
|
||||
}
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
const targetKeys = Object.keys(target);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
if (isUnsafeKey(targetKeys[i])) continue;
|
||||
applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
|
||||
}
|
||||
const previousKeys = Object.keys(previous);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
|
||||
}
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
const {
|
||||
merge,
|
||||
key = "id"
|
||||
} = options,
|
||||
v = unwrap(value);
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(v)) return v;
|
||||
const res = applyState(v, {
|
||||
[$ROOT]: state
|
||||
}, $ROOT, merge, key);
|
||||
return res === undefined ? state : res;
|
||||
};
|
||||
}
|
||||
const producers = new WeakMap();
|
||||
const setterTraps = {
|
||||
get(target, property) {
|
||||
if (property === $RAW) return target;
|
||||
const value = target[property];
|
||||
if (property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
let proxy;
|
||||
return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
|
||||
},
|
||||
set(target, property, value) {
|
||||
setProperty(target, property, unwrap(value));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
setProperty(target, property, undefined, true);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) {
|
||||
let proxy;
|
||||
if (!(proxy = producers.get(state))) {
|
||||
producers.set(state, proxy = new Proxy(state, setterTraps));
|
||||
}
|
||||
fn(proxy);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
|
||||
const DEV = undefined;
|
||||
|
||||
exports.$RAW = $RAW;
|
||||
exports.DEV = DEV;
|
||||
exports.createMutable = createMutable;
|
||||
exports.createStore = createStore;
|
||||
exports.modifyMutable = modifyMutable;
|
||||
exports.produce = produce;
|
||||
exports.reconcile = reconcile;
|
||||
exports.unwrap = unwrap;
|
||||
454
go/jsruntime/runtime/solid-js/store/dist/store.js
vendored
Normal file
454
go/jsruntime/runtime/solid-js/store/dist/store.js
vendored
Normal file
@@ -0,0 +1,454 @@
|
||||
import { batch, $PROXY, $TRACK, getListener, createSignal } from 'solid-js';
|
||||
|
||||
const $RAW = Symbol("store-raw"),
|
||||
$NODE = Symbol("store-node"),
|
||||
$HAS = Symbol("store-has"),
|
||||
$SELF = Symbol("store-self");
|
||||
function wrap$1(value) {
|
||||
let p = value[$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, $PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps$1)
|
||||
});
|
||||
if (!Array.isArray(value)) {
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value),
|
||||
proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(proto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
Object.defineProperty(value, prop, {
|
||||
configurable: true,
|
||||
enumerable: desc[prop].enumerable,
|
||||
get: desc[prop].get.bind(p)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function isWrappable(obj) {
|
||||
let proto;
|
||||
return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
|
||||
}
|
||||
function unwrap(item, set = new Set()) {
|
||||
let result, unwrapped, v, prop;
|
||||
if (result = item != null && item[$RAW]) return result;
|
||||
if (!isWrappable(item) || set.has(item)) return item;
|
||||
if (Array.isArray(item)) {
|
||||
if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
|
||||
for (let i = 0, l = item.length; i < l; i++) {
|
||||
v = item[i];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
|
||||
}
|
||||
} else {
|
||||
if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
|
||||
const keys = Object.keys(item),
|
||||
desc = Object.getOwnPropertyDescriptors(item);
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
prop = keys[i];
|
||||
if (desc[prop].get) continue;
|
||||
v = item[prop];
|
||||
if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
function getNodes(target, symbol) {
|
||||
let nodes = target[symbol];
|
||||
if (!nodes) Object.defineProperty(target, symbol, {
|
||||
value: nodes = Object.create(null)
|
||||
});
|
||||
return nodes;
|
||||
}
|
||||
function getNode(nodes, property, value) {
|
||||
if (nodes[property]) return nodes[property];
|
||||
const [s, set] = createSignal(value, {
|
||||
equals: false,
|
||||
internal: true
|
||||
});
|
||||
s.$ = set;
|
||||
return nodes[property] = s;
|
||||
}
|
||||
function proxyDescriptor$1(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[$PROXY][property];
|
||||
return desc;
|
||||
}
|
||||
function trackSelf(target) {
|
||||
getListener() && getNode(getNodes(target, $NODE), $SELF)();
|
||||
}
|
||||
function ownKeys(target) {
|
||||
trackSelf(target);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const proxyTraps$1 = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === $PROXY) return receiver;
|
||||
if (property === $TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
if (getListener() && (typeof value !== "function" || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
|
||||
}
|
||||
return isWrappable(value) ? wrap$1(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set() {
|
||||
return true;
|
||||
},
|
||||
deleteProperty() {
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor$1
|
||||
};
|
||||
function setProperty(state, property, value, deleting = false) {
|
||||
if (property === "__proto__") {
|
||||
return;
|
||||
}
|
||||
if (!deleting && state[property] === value) return;
|
||||
const prev = state[property],
|
||||
len = state.length;
|
||||
if (value === undefined) {
|
||||
delete state[property];
|
||||
if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
|
||||
} else {
|
||||
state[property] = value;
|
||||
if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
|
||||
}
|
||||
let nodes = getNodes(state, $NODE),
|
||||
node;
|
||||
if (node = getNode(nodes, property, prev)) node.$(() => value);
|
||||
if (Array.isArray(state) && state.length !== len) {
|
||||
for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
|
||||
(node = getNode(nodes, "length", len)) && node.$(state.length);
|
||||
}
|
||||
(node = nodes[$SELF]) && node.$();
|
||||
}
|
||||
function mergeStoreNode(state, value) {
|
||||
const keys = Object.keys(value);
|
||||
for (let i = 0; i < keys.length; i += 1) {
|
||||
const key = keys[i];
|
||||
if (isUnsafeKey$1(key)) continue;
|
||||
setProperty(state, key, value[key]);
|
||||
}
|
||||
}
|
||||
function isUnsafeKey$1(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function updateArray(current, next) {
|
||||
if (typeof next === "function") next = next(current);
|
||||
next = unwrap(next);
|
||||
if (Array.isArray(next)) {
|
||||
if (current === next) return;
|
||||
let i = 0,
|
||||
len = next.length;
|
||||
for (; i < len; i++) {
|
||||
const value = next[i];
|
||||
if (current[i] !== value) setProperty(current, i, value);
|
||||
}
|
||||
setProperty(current, "length", len);
|
||||
} else mergeStoreNode(current, next);
|
||||
}
|
||||
function updatePath(current, path, traversed = []) {
|
||||
let part,
|
||||
prev = current;
|
||||
if (path.length > 1) {
|
||||
part = path.shift();
|
||||
const partType = typeof part,
|
||||
isArray = Array.isArray(current);
|
||||
if (partType === "string" && (part === "__proto__" || path.length > 1 && isUnsafeKey$1(part))) {
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(part)) {
|
||||
for (let i = 0; i < part.length; i++) {
|
||||
updatePath(current, [part[i]].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "function") {
|
||||
for (let i = 0; i < current.length; i++) {
|
||||
if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (isArray && partType === "object") {
|
||||
const {
|
||||
from = 0,
|
||||
to = current.length - 1,
|
||||
by = 1
|
||||
} = part;
|
||||
for (let i = from; i <= to; i += by) {
|
||||
updatePath(current, [i].concat(path), traversed);
|
||||
}
|
||||
return;
|
||||
} else if (path.length > 1) {
|
||||
updatePath(current[part], path, [part].concat(traversed));
|
||||
return;
|
||||
}
|
||||
prev = current[part];
|
||||
traversed = [part].concat(traversed);
|
||||
}
|
||||
let value = path[0];
|
||||
if (typeof value === "function") {
|
||||
value = value(prev, traversed);
|
||||
if (value === prev) return;
|
||||
}
|
||||
if (part === undefined && value == undefined) return;
|
||||
value = unwrap(value);
|
||||
if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
|
||||
mergeStoreNode(prev, value);
|
||||
} else setProperty(current, part, value);
|
||||
}
|
||||
function createStore(...[store, options]) {
|
||||
const unwrappedStore = unwrap(store || {});
|
||||
const isArray = Array.isArray(unwrappedStore);
|
||||
const wrappedStore = wrap$1(unwrappedStore);
|
||||
function setStore(...args) {
|
||||
batch(() => {
|
||||
isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
|
||||
});
|
||||
}
|
||||
return [wrappedStore, setStore];
|
||||
}
|
||||
|
||||
function proxyDescriptor(target, property) {
|
||||
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
||||
if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
|
||||
delete desc.value;
|
||||
delete desc.writable;
|
||||
desc.get = () => target[$PROXY][property];
|
||||
desc.set = v => target[$PROXY][property] = v;
|
||||
return desc;
|
||||
}
|
||||
const proxyTraps = {
|
||||
get(target, property, receiver) {
|
||||
if (property === $RAW) return target;
|
||||
if (property === $PROXY) return receiver;
|
||||
if (property === $TRACK) {
|
||||
trackSelf(target);
|
||||
return receiver;
|
||||
}
|
||||
const nodes = getNodes(target, $NODE);
|
||||
const tracked = nodes[property];
|
||||
let value = tracked ? tracked() : target[property];
|
||||
if (property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
if (!tracked) {
|
||||
const desc = Object.getOwnPropertyDescriptor(target, property);
|
||||
const isFunction = typeof value === "function";
|
||||
if (getListener() && (!isFunction || Object.prototype.hasOwnProperty.call(target, property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
|
||||
return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
|
||||
}
|
||||
}
|
||||
return isWrappable(value) ? wrap(value) : value;
|
||||
},
|
||||
has(target, property) {
|
||||
if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
|
||||
getListener() && getNode(getNodes(target, $HAS), property)();
|
||||
return property in target;
|
||||
},
|
||||
set(target, property, value) {
|
||||
batch(() => setProperty(target, property, unwrap(value)));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
batch(() => setProperty(target, property, undefined, true));
|
||||
return true;
|
||||
},
|
||||
ownKeys: ownKeys,
|
||||
getOwnPropertyDescriptor: proxyDescriptor
|
||||
};
|
||||
function wrap(value) {
|
||||
let p = value[$PROXY];
|
||||
if (!p) {
|
||||
Object.defineProperty(value, $PROXY, {
|
||||
value: p = new Proxy(value, proxyTraps)
|
||||
});
|
||||
const keys = Object.keys(value),
|
||||
desc = Object.getOwnPropertyDescriptors(value);
|
||||
const proto = Object.getPrototypeOf(value);
|
||||
const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
|
||||
if (isClass) {
|
||||
let curProto = proto;
|
||||
while (curProto != null) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(curProto);
|
||||
keys.push(...Object.keys(descriptors));
|
||||
Object.assign(desc, descriptors);
|
||||
curProto = Object.getPrototypeOf(curProto);
|
||||
}
|
||||
}
|
||||
for (let i = 0, l = keys.length; i < l; i++) {
|
||||
const prop = keys[i];
|
||||
if (isClass && prop === "constructor") continue;
|
||||
if (desc[prop].get) {
|
||||
const get = desc[prop].get.bind(p);
|
||||
Object.defineProperty(value, prop, {
|
||||
get,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (desc[prop].set) {
|
||||
const og = desc[prop].set,
|
||||
set = v => batch(() => og.call(p, v));
|
||||
Object.defineProperty(value, prop, {
|
||||
set,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
function createMutable(state, options) {
|
||||
const unwrappedStore = unwrap(state || {});
|
||||
const wrappedStore = wrap(unwrappedStore);
|
||||
return wrappedStore;
|
||||
}
|
||||
function modifyMutable(state, modifier) {
|
||||
batch(() => modifier(unwrap(state)));
|
||||
}
|
||||
|
||||
const $ROOT = Symbol("store-root");
|
||||
function isUnsafeKey(property) {
|
||||
return property === "__proto__" || property === "constructor" || property === "prototype";
|
||||
}
|
||||
function applyState(target, parent, property, merge, key) {
|
||||
if (isUnsafeKey(property)) return;
|
||||
const previous = parent[property];
|
||||
if (target === previous) return;
|
||||
const isArray = Array.isArray(target);
|
||||
if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
|
||||
setProperty(parent, property, target);
|
||||
return;
|
||||
}
|
||||
if (isArray) {
|
||||
if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
|
||||
let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
|
||||
for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
|
||||
applyState(target[start], previous, start, merge, key);
|
||||
}
|
||||
const temp = new Array(target.length),
|
||||
newIndices = new Map();
|
||||
for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
|
||||
temp[newEnd] = previous[end];
|
||||
}
|
||||
if (start > newEnd || start > end) {
|
||||
for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
|
||||
for (; j < target.length; j++) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
newIndicesNext = new Array(newEnd + 1);
|
||||
for (j = newEnd; j >= start; j--) {
|
||||
item = target[j];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
i = newIndices.get(keyVal);
|
||||
newIndicesNext[j] = i === undefined ? -1 : i;
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
for (i = start; i <= end; i++) {
|
||||
item = previous[i];
|
||||
keyVal = key && item ? item[key] : item;
|
||||
j = newIndices.get(keyVal);
|
||||
if (j !== undefined && j !== -1) {
|
||||
temp[j] = previous[i];
|
||||
j = newIndicesNext[j];
|
||||
newIndices.set(keyVal, j);
|
||||
}
|
||||
}
|
||||
for (j = start; j < target.length; j++) {
|
||||
if (j in temp) {
|
||||
setProperty(previous, j, temp[j]);
|
||||
applyState(target[j], previous, j, merge, key);
|
||||
} else setProperty(previous, j, target[j]);
|
||||
}
|
||||
} else {
|
||||
for (let i = 0, len = target.length; i < len; i++) {
|
||||
applyState(target[i], previous, i, merge, key);
|
||||
}
|
||||
}
|
||||
if (previous.length > target.length) setProperty(previous, "length", target.length);
|
||||
return;
|
||||
}
|
||||
const targetKeys = Object.keys(target);
|
||||
for (let i = 0, len = targetKeys.length; i < len; i++) {
|
||||
if (isUnsafeKey(targetKeys[i])) continue;
|
||||
applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
|
||||
}
|
||||
const previousKeys = Object.keys(previous);
|
||||
for (let i = 0, len = previousKeys.length; i < len; i++) {
|
||||
if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
|
||||
}
|
||||
}
|
||||
function reconcile(value, options = {}) {
|
||||
const {
|
||||
merge,
|
||||
key = "id"
|
||||
} = options,
|
||||
v = unwrap(value);
|
||||
return state => {
|
||||
if (!isWrappable(state) || !isWrappable(v)) return v;
|
||||
const res = applyState(v, {
|
||||
[$ROOT]: state
|
||||
}, $ROOT, merge, key);
|
||||
return res === undefined ? state : res;
|
||||
};
|
||||
}
|
||||
const producers = new WeakMap();
|
||||
const setterTraps = {
|
||||
get(target, property) {
|
||||
if (property === $RAW) return target;
|
||||
const value = target[property];
|
||||
if (property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return value;
|
||||
let proxy;
|
||||
return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
|
||||
},
|
||||
set(target, property, value) {
|
||||
setProperty(target, property, unwrap(value));
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
setProperty(target, property, undefined, true);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
function produce(fn) {
|
||||
return state => {
|
||||
if (isWrappable(state)) {
|
||||
let proxy;
|
||||
if (!(proxy = producers.get(state))) {
|
||||
producers.set(state, proxy = new Proxy(state, setterTraps));
|
||||
}
|
||||
fn(proxy);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
}
|
||||
|
||||
const DEV = undefined;
|
||||
|
||||
export { $RAW, DEV, createMutable, createStore, modifyMutable, produce, reconcile, unwrap };
|
||||
46
go/jsruntime/runtime/solid-js/store/package.json
Normal file
46
go/jsruntime/runtime/solid-js/store/package.json
Normal file
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"name": "solid-js/store",
|
||||
"main": "./dist/server.cjs",
|
||||
"module": "./dist/server.js",
|
||||
"unpkg": "./dist/store.cjs",
|
||||
"types": "./types/index.d.ts",
|
||||
"type": "module",
|
||||
"sideEffects": false,
|
||||
"exports": {
|
||||
".": {
|
||||
"worker": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/server.js",
|
||||
"require": "./dist/server.cjs"
|
||||
},
|
||||
"browser": {
|
||||
"development": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/dev.js",
|
||||
"require": "./dist/dev.cjs"
|
||||
},
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/store.js",
|
||||
"require": "./dist/store.cjs"
|
||||
},
|
||||
"deno": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/server.js",
|
||||
"require": "./dist/server.cjs"
|
||||
},
|
||||
"node": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/server.js",
|
||||
"require": "./dist/server.cjs"
|
||||
},
|
||||
"development": {
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/dev.js",
|
||||
"require": "./dist/dev.cjs"
|
||||
},
|
||||
"types": "./types/index.d.ts",
|
||||
"import": "./dist/store.js",
|
||||
"require": "./dist/store.cjs"
|
||||
}
|
||||
}
|
||||
}
|
||||
12
go/jsruntime/runtime/solid-js/store/types/index.d.ts
vendored
Normal file
12
go/jsruntime/runtime/solid-js/store/types/index.d.ts
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
export { $RAW, createStore, unwrap } from "./store.js";
|
||||
export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StoreReturn, StorePathRange, StoreSetter } from "./store.js";
|
||||
export * from "./mutable.js";
|
||||
export * from "./modifiers.js";
|
||||
import { $NODE, isWrappable } from "./store.js";
|
||||
export declare const DEV: {
|
||||
readonly $NODE: typeof $NODE;
|
||||
readonly isWrappable: typeof isWrappable;
|
||||
readonly hooks: {
|
||||
onStoreNodeUpdate: import("./store.js").OnStoreNodeUpdate | null;
|
||||
};
|
||||
} | undefined;
|
||||
6
go/jsruntime/runtime/solid-js/store/types/modifiers.d.ts
vendored
Normal file
6
go/jsruntime/runtime/solid-js/store/types/modifiers.d.ts
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
export type ReconcileOptions = {
|
||||
key?: string | null;
|
||||
merge?: boolean;
|
||||
};
|
||||
export declare function reconcile<T extends U, U>(value: T, options?: ReconcileOptions): (state: U) => T;
|
||||
export declare function produce<T>(fn: (state: T) => void): (state: T) => T;
|
||||
5
go/jsruntime/runtime/solid-js/store/types/mutable.d.ts
vendored
Normal file
5
go/jsruntime/runtime/solid-js/store/types/mutable.d.ts
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import { StoreNode } from "./store.js";
|
||||
export declare function createMutable<T extends StoreNode>(state: T, options?: {
|
||||
name?: string;
|
||||
}): T;
|
||||
export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;
|
||||
17
go/jsruntime/runtime/solid-js/store/types/server.d.ts
vendored
Normal file
17
go/jsruntime/runtime/solid-js/store/types/server.d.ts
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
import type { Store, StoreReturn } from "./store.js";
|
||||
export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StoreReturn, StorePathRange, StoreSetter } from "./store.js";
|
||||
export declare const $RAW: unique symbol;
|
||||
export declare function isWrappable(obj: any): boolean;
|
||||
export declare function unwrap<T>(item: T): T;
|
||||
export declare function setProperty(state: any, property: PropertyKey, value: any, force?: boolean): void;
|
||||
export declare function updatePath(current: any, path: any[], traversed?: PropertyKey[]): void;
|
||||
export declare function createStore<T>(state: T | Store<T>): StoreReturn<T>;
|
||||
export declare function createMutable<T>(state: T | Store<T>): T;
|
||||
export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;
|
||||
type ReconcileOptions = {
|
||||
key?: string | null;
|
||||
merge?: boolean;
|
||||
};
|
||||
export declare function reconcile<T extends U, U extends object>(value: T, options?: ReconcileOptions): (state: U) => T;
|
||||
export declare function produce<T>(fn: (state: T) => void): (state: T) => T;
|
||||
export declare const DEV: undefined;
|
||||
108
go/jsruntime/runtime/solid-js/store/types/store.d.ts
vendored
Normal file
108
go/jsruntime/runtime/solid-js/store/types/store.d.ts
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
export declare const IS_DEV: string | boolean;
|
||||
export declare const $RAW: unique symbol, $NODE: unique symbol, $HAS: unique symbol, $SELF: unique symbol;
|
||||
export declare const DevHooks: {
|
||||
onStoreNodeUpdate: OnStoreNodeUpdate | null;
|
||||
};
|
||||
type DataNode = {
|
||||
(): any;
|
||||
$(value?: any): void;
|
||||
};
|
||||
export type DataNodes = Record<PropertyKey, DataNode | undefined>;
|
||||
export type OnStoreNodeUpdate = (state: StoreNode, property: PropertyKey, value: StoreNode | NotWrappable, prev: StoreNode | NotWrappable) => void;
|
||||
export interface StoreNode {
|
||||
[$NODE]?: DataNodes;
|
||||
[key: PropertyKey]: any;
|
||||
}
|
||||
export declare namespace SolidStore {
|
||||
interface Unwrappable {
|
||||
}
|
||||
}
|
||||
export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
|
||||
export type Store<T> = T;
|
||||
export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
|
||||
/**
|
||||
* Returns the underlying data in the store without a proxy.
|
||||
* @param item store proxy object
|
||||
* @example
|
||||
* ```js
|
||||
* const initial = {z...};
|
||||
* const [state, setState] = createStore(initial);
|
||||
* initial === state; // => false
|
||||
* initial === unwrap(state); // => true
|
||||
* ```
|
||||
*/
|
||||
export declare function unwrap<T>(item: T, set?: Set<unknown>): T;
|
||||
export declare function getNodes(target: StoreNode, symbol: typeof $NODE | typeof $HAS): DataNodes;
|
||||
export declare function getNode(nodes: DataNodes, property: PropertyKey, value?: any): DataNode;
|
||||
export declare function proxyDescriptor(target: StoreNode, property: PropertyKey): TypedPropertyDescriptor<any> | undefined;
|
||||
export declare function trackSelf(target: StoreNode): void;
|
||||
export declare function ownKeys(target: StoreNode): (string | symbol)[];
|
||||
export declare function setProperty(state: StoreNode, property: PropertyKey, value: any, deleting?: boolean): void;
|
||||
export declare function updatePath(current: StoreNode, path: any[], traversed?: PropertyKey[]): void;
|
||||
/** @deprecated */
|
||||
export type DeepReadonly<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
|
||||
readonly [K in keyof T]: DeepReadonly<T[K]>;
|
||||
};
|
||||
/** @deprecated */
|
||||
export type DeepMutable<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
|
||||
-readonly [K in keyof T]: DeepMutable<T[K]>;
|
||||
};
|
||||
export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
|
||||
[K in Extract<keyof T, `${number}`>]?: T[K];
|
||||
} : {
|
||||
[x: number]: T[number];
|
||||
} : Partial<T>;
|
||||
export type PickMutable<T> = {
|
||||
[K in keyof T as (<U>() => U extends {
|
||||
[V in K]: T[V];
|
||||
} ? 1 : 2) extends <U>() => U extends {
|
||||
-readonly [V in K]: T[V];
|
||||
} ? 1 : 2 ? K : never]: T[K];
|
||||
};
|
||||
export type StorePathRange = {
|
||||
from?: number;
|
||||
to?: number;
|
||||
by?: number;
|
||||
};
|
||||
export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
|
||||
export type StoreSetter<T, U extends PropertyKey[] = []> = T | CustomPartial<T> | ((prevState: T, traversed: U) => T | CustomPartial<T>);
|
||||
export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
|
||||
type W<T> = Exclude<T, NotWrappable>;
|
||||
type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [
|
||||
T
|
||||
] extends [readonly unknown[]] ? number : keyof T : keyof T;
|
||||
type MutableKeyOf<T> = KeyOf<T> & keyof PickMutable<T>;
|
||||
type Rest<T, U extends PropertyKey[], K extends KeyOf<T> = KeyOf<T>> = [T] extends [never] ? never : K extends MutableKeyOf<T> ? [Part<T, K>, ...RestSetterOrContinue<T[K], [K, ...U]>] : K extends KeyOf<T> ? [Part<T, K>, ...RestContinue<T[K], [K, ...U]>] : never;
|
||||
type RestContinue<T, U extends PropertyKey[]> = 0 extends 1 & T ? [...Part<any>[], StoreSetter<any, PropertyKey[]>] : Rest<W<T>, U>;
|
||||
type RestSetterOrContinue<T, U extends PropertyKey[]> = [StoreSetter<T, U>] | RestContinue<T, U>;
|
||||
export interface SetStoreFunction<T> {
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends MutableKeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: StoreSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [
|
||||
K7,
|
||||
K6,
|
||||
K5,
|
||||
K4,
|
||||
K3,
|
||||
K2,
|
||||
K1
|
||||
]>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends MutableKeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: StoreSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6], [K6, K5, K4, K3, K2, K1]>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends MutableKeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: StoreSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5], [K5, K4, K3, K2, K1]>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends MutableKeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: StoreSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4], [K4, K3, K2, K1]>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends MutableKeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: StoreSetter<W<W<W<T>[K1]>[K2]>[K3], [K3, K2, K1]>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends MutableKeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: StoreSetter<W<W<T>[K1]>[K2], [K2, K1]>): void;
|
||||
<K1 extends MutableKeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: StoreSetter<W<T>[K1], [K1]>): void;
|
||||
(setter: StoreSetter<T, []>): void;
|
||||
<K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, ...rest: Rest<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [K7, K6, K5, K4, K3, K2, K1]>): void;
|
||||
}
|
||||
export type StoreReturn<T> = [get: Store<T>, set: SetStoreFunction<T>];
|
||||
/**
|
||||
* Creates a reactive store that can be read through a proxy object and written with a setter function
|
||||
*
|
||||
* @description https://docs.solidjs.com/reference/store-utilities/create-store
|
||||
*/
|
||||
export declare function createStore<T extends object = {}>(...[store, options]: {} extends T ? [store?: T | Store<T>, options?: {
|
||||
name?: string;
|
||||
}] : [store: T | Store<T>, options?: {
|
||||
name?: string;
|
||||
}]): StoreReturn<T>;
|
||||
export {};
|
||||
Reference in New Issue
Block a user