6598 lines
220 KiB
JavaScript
6598 lines
220 KiB
JavaScript
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __defProps = Object.defineProperties;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a2, b2) => {
|
|
for (var prop in b2 || (b2 = {}))
|
|
if (__hasOwnProp.call(b2, prop))
|
|
__defNormalProp(a2, prop, b2[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b2)) {
|
|
if (__propIsEnum.call(b2, prop))
|
|
__defNormalProp(a2, prop, b2[prop]);
|
|
}
|
|
return a2;
|
|
};
|
|
var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var __publicField = (obj, key, value) => {
|
|
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
return value;
|
|
};
|
|
|
|
// ../node_modules/timing-function/lib/UnitBezier.js
|
|
var require_UnitBezier = __commonJS({
|
|
"../node_modules/timing-function/lib/UnitBezier.js"(exports2, module2) {
|
|
var UnitBezier2;
|
|
module2.exports = UnitBezier2 = function() {
|
|
function UnitBezier3(p1x, p1y, p2x, p2y) {
|
|
this.set(p1x, p1y, p2x, p2y);
|
|
}
|
|
UnitBezier3.prototype.set = function(p1x, p1y, p2x, p2y) {
|
|
this._cx = 3 * p1x;
|
|
this._bx = 3 * (p2x - p1x) - this._cx;
|
|
this._ax = 1 - this._cx - this._bx;
|
|
this._cy = 3 * p1y;
|
|
this._by = 3 * (p2y - p1y) - this._cy;
|
|
this._ay = 1 - this._cy - this._by;
|
|
};
|
|
UnitBezier3.epsilon = 1e-6;
|
|
UnitBezier3.prototype._sampleCurveX = function(t2) {
|
|
return ((this._ax * t2 + this._bx) * t2 + this._cx) * t2;
|
|
};
|
|
UnitBezier3.prototype._sampleCurveY = function(t2) {
|
|
return ((this._ay * t2 + this._by) * t2 + this._cy) * t2;
|
|
};
|
|
UnitBezier3.prototype._sampleCurveDerivativeX = function(t2) {
|
|
return (3 * this._ax * t2 + 2 * this._bx) * t2 + this._cx;
|
|
};
|
|
UnitBezier3.prototype._solveCurveX = function(x2, epsilon) {
|
|
var d2, i2, t0, t1, t2, x22;
|
|
t0 = void 0;
|
|
t1 = void 0;
|
|
t2 = void 0;
|
|
x22 = void 0;
|
|
d2 = void 0;
|
|
i2 = void 0;
|
|
t2 = x2;
|
|
i2 = 0;
|
|
while (i2 < 8) {
|
|
x22 = this._sampleCurveX(t2) - x2;
|
|
if (Math.abs(x22) < epsilon) {
|
|
return t2;
|
|
}
|
|
d2 = this._sampleCurveDerivativeX(t2);
|
|
if (Math.abs(d2) < epsilon) {
|
|
break;
|
|
}
|
|
t2 = t2 - x22 / d2;
|
|
i2++;
|
|
}
|
|
t0 = 0;
|
|
t1 = 1;
|
|
t2 = x2;
|
|
if (t2 < t0) {
|
|
return t0;
|
|
}
|
|
if (t2 > t1) {
|
|
return t1;
|
|
}
|
|
while (t0 < t1) {
|
|
x22 = this._sampleCurveX(t2);
|
|
if (Math.abs(x22 - x2) < epsilon) {
|
|
return t2;
|
|
}
|
|
if (x2 > x22) {
|
|
t0 = t2;
|
|
} else {
|
|
t1 = t2;
|
|
}
|
|
t2 = (t1 - t0) * 0.5 + t0;
|
|
}
|
|
return t2;
|
|
};
|
|
UnitBezier3.prototype.solve = function(x2, epsilon) {
|
|
return this._sampleCurveY(this._solveCurveX(x2, epsilon));
|
|
};
|
|
UnitBezier3.prototype.solveSimple = function(x2) {
|
|
return this._sampleCurveY(this._solveCurveX(x2, 1e-6));
|
|
};
|
|
return UnitBezier3;
|
|
}();
|
|
}
|
|
});
|
|
|
|
// ../node_modules/levenshtein-edit-distance/index.js
|
|
var require_levenshtein_edit_distance = __commonJS({
|
|
"../node_modules/levenshtein-edit-distance/index.js"(exports2, module2) {
|
|
var cache2;
|
|
var codes;
|
|
cache2 = [];
|
|
codes = [];
|
|
function levenshtein(value, other, insensitive) {
|
|
var length, lengthOther, code, result, distance, distanceOther, index, indexOther;
|
|
if (value === other) {
|
|
return 0;
|
|
}
|
|
length = value.length;
|
|
lengthOther = other.length;
|
|
if (length === 0) {
|
|
return lengthOther;
|
|
}
|
|
if (lengthOther === 0) {
|
|
return length;
|
|
}
|
|
if (insensitive) {
|
|
value = value.toLowerCase();
|
|
other = other.toLowerCase();
|
|
}
|
|
index = 0;
|
|
while (index < length) {
|
|
codes[index] = value.charCodeAt(index);
|
|
cache2[index] = ++index;
|
|
}
|
|
indexOther = 0;
|
|
while (indexOther < lengthOther) {
|
|
code = other.charCodeAt(indexOther);
|
|
result = distance = indexOther++;
|
|
index = -1;
|
|
while (++index < length) {
|
|
distanceOther = code === codes[index] ? distance : distance + 1;
|
|
distance = cache2[index];
|
|
cache2[index] = result = distance > result ? distanceOther > result ? result + 1 : distanceOther : distanceOther > distance ? distance + 1 : distanceOther;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
module2.exports = levenshtein;
|
|
}
|
|
});
|
|
|
|
// ../node_modules/propose/propose.js
|
|
var require_propose = __commonJS({
|
|
"../node_modules/propose/propose.js"(exports2, module2) {
|
|
var levenshtein = require_levenshtein_edit_distance();
|
|
function propose2() {
|
|
var ratio;
|
|
var distance;
|
|
var proposed;
|
|
var threshold;
|
|
var ignoreCase;
|
|
var max_ratio = 0;
|
|
var word = arguments[0];
|
|
var dictionary = arguments[1];
|
|
var len = dictionary.length;
|
|
var options = arguments[2];
|
|
if (options) {
|
|
threshold = options.threshold;
|
|
ignoreCase = options.ignoreCase;
|
|
}
|
|
if (threshold === void 0)
|
|
threshold = 0;
|
|
for (var i2 = 0; i2 < len; ++i2) {
|
|
if (ignoreCase)
|
|
distance = levenshtein(word, dictionary[i2], true);
|
|
else
|
|
distance = levenshtein(word, dictionary[i2]);
|
|
if (distance > word.length)
|
|
ratio = 1 - distance / dictionary[i2].length;
|
|
else
|
|
ratio = 1 - distance / word.length;
|
|
if (ratio > max_ratio) {
|
|
max_ratio = ratio;
|
|
proposed = dictionary[i2];
|
|
}
|
|
}
|
|
if (max_ratio >= threshold)
|
|
return proposed;
|
|
return null;
|
|
}
|
|
module2.exports = propose2;
|
|
}
|
|
});
|
|
|
|
// ../node_modules/fast-deep-equal/index.js
|
|
var require_fast_deep_equal = __commonJS({
|
|
"../node_modules/fast-deep-equal/index.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function equal(a2, b2) {
|
|
if (a2 === b2)
|
|
return true;
|
|
if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
|
|
if (a2.constructor !== b2.constructor)
|
|
return false;
|
|
var length, i2, keys2;
|
|
if (Array.isArray(a2)) {
|
|
length = a2.length;
|
|
if (length != b2.length)
|
|
return false;
|
|
for (i2 = length; i2-- !== 0; )
|
|
if (!equal(a2[i2], b2[i2]))
|
|
return false;
|
|
return true;
|
|
}
|
|
if (a2.constructor === RegExp)
|
|
return a2.source === b2.source && a2.flags === b2.flags;
|
|
if (a2.valueOf !== Object.prototype.valueOf)
|
|
return a2.valueOf() === b2.valueOf();
|
|
if (a2.toString !== Object.prototype.toString)
|
|
return a2.toString() === b2.toString();
|
|
keys2 = Object.keys(a2);
|
|
length = keys2.length;
|
|
if (length !== Object.keys(b2).length)
|
|
return false;
|
|
for (i2 = length; i2-- !== 0; )
|
|
if (!Object.prototype.hasOwnProperty.call(b2, keys2[i2]))
|
|
return false;
|
|
for (i2 = length; i2-- !== 0; ) {
|
|
var key = keys2[i2];
|
|
if (!equal(a2[key], b2[key]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return a2 !== a2 && b2 !== b2;
|
|
};
|
|
}
|
|
});
|
|
|
|
// core/src/index.ts
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
createRafDriver: () => createRafDriver,
|
|
getProject: () => getProject,
|
|
notify: () => notify,
|
|
onChange: () => onChange,
|
|
types: () => propTypes_exports,
|
|
val: () => val7
|
|
});
|
|
module.exports = __toCommonJS(src_exports);
|
|
|
|
// core/src/coreExports.ts
|
|
var coreExports_exports = {};
|
|
__export(coreExports_exports, {
|
|
createRafDriver: () => createRafDriver,
|
|
getProject: () => getProject,
|
|
notify: () => notify,
|
|
onChange: () => onChange,
|
|
types: () => propTypes_exports,
|
|
val: () => val7
|
|
});
|
|
|
|
// core/src/projects/projectsSingleton.ts
|
|
var import_dataverse = require("@theatre/dataverse");
|
|
var ProjectsSingleton = class {
|
|
constructor() {
|
|
__publicField(this, "atom", new import_dataverse.Atom({ projects: {} }));
|
|
}
|
|
/**
|
|
* We're trusting here that each project id is unique
|
|
*/
|
|
add(id, project) {
|
|
this.atom.setByPointer((p2) => p2.projects[id], project);
|
|
}
|
|
get(id) {
|
|
return this.atom.get().projects[id];
|
|
}
|
|
has(id) {
|
|
return !!this.get(id);
|
|
}
|
|
};
|
|
var singleton = new ProjectsSingleton();
|
|
var projectsSingleton_default = singleton;
|
|
|
|
// core/src/privateAPIs.ts
|
|
var publicAPIToPrivateAPIMap = /* @__PURE__ */ new WeakMap();
|
|
function privateAPI(pub) {
|
|
return publicAPIToPrivateAPIMap.get(pub);
|
|
}
|
|
function setPrivateAPI(pub, priv) {
|
|
publicAPIToPrivateAPIMap.set(pub, priv);
|
|
}
|
|
|
|
// shared/src/utils/index.ts
|
|
var emptyArray = [];
|
|
|
|
// ../node_modules/lodash-es/isArray.js
|
|
var isArray = Array.isArray;
|
|
var isArray_default = isArray;
|
|
|
|
// ../node_modules/lodash-es/_freeGlobal.js
|
|
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
|
var freeGlobal_default = freeGlobal;
|
|
|
|
// ../node_modules/lodash-es/_root.js
|
|
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
|
var root = freeGlobal_default || freeSelf || Function("return this")();
|
|
var root_default = root;
|
|
|
|
// ../node_modules/lodash-es/_Symbol.js
|
|
var Symbol2 = root_default.Symbol;
|
|
var Symbol_default = Symbol2;
|
|
|
|
// ../node_modules/lodash-es/_getRawTag.js
|
|
var objectProto = Object.prototype;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var nativeObjectToString = objectProto.toString;
|
|
var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
|
|
function getRawTag(value) {
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
|
|
try {
|
|
value[symToStringTag] = void 0;
|
|
var unmasked = true;
|
|
} catch (e2) {
|
|
}
|
|
var result = nativeObjectToString.call(value);
|
|
if (unmasked) {
|
|
if (isOwn) {
|
|
value[symToStringTag] = tag;
|
|
} else {
|
|
delete value[symToStringTag];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var getRawTag_default = getRawTag;
|
|
|
|
// ../node_modules/lodash-es/_objectToString.js
|
|
var objectProto2 = Object.prototype;
|
|
var nativeObjectToString2 = objectProto2.toString;
|
|
function objectToString(value) {
|
|
return nativeObjectToString2.call(value);
|
|
}
|
|
var objectToString_default = objectToString;
|
|
|
|
// ../node_modules/lodash-es/_baseGetTag.js
|
|
var nullTag = "[object Null]";
|
|
var undefinedTag = "[object Undefined]";
|
|
var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
|
|
function baseGetTag(value) {
|
|
if (value == null) {
|
|
return value === void 0 ? undefinedTag : nullTag;
|
|
}
|
|
return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
|
|
}
|
|
var baseGetTag_default = baseGetTag;
|
|
|
|
// ../node_modules/lodash-es/isObjectLike.js
|
|
function isObjectLike(value) {
|
|
return value != null && typeof value == "object";
|
|
}
|
|
var isObjectLike_default = isObjectLike;
|
|
|
|
// ../node_modules/lodash-es/isSymbol.js
|
|
var symbolTag = "[object Symbol]";
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
|
|
}
|
|
var isSymbol_default = isSymbol;
|
|
|
|
// ../node_modules/lodash-es/_isKey.js
|
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
|
|
var reIsPlainProp = /^\w*$/;
|
|
function isKey(value, object) {
|
|
if (isArray_default(value)) {
|
|
return false;
|
|
}
|
|
var type = typeof value;
|
|
if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
|
|
return true;
|
|
}
|
|
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
|
|
}
|
|
var isKey_default = isKey;
|
|
|
|
// ../node_modules/lodash-es/isObject.js
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return value != null && (type == "object" || type == "function");
|
|
}
|
|
var isObject_default = isObject;
|
|
|
|
// ../node_modules/lodash-es/isFunction.js
|
|
var asyncTag = "[object AsyncFunction]";
|
|
var funcTag = "[object Function]";
|
|
var genTag = "[object GeneratorFunction]";
|
|
var proxyTag = "[object Proxy]";
|
|
function isFunction(value) {
|
|
if (!isObject_default(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag_default(value);
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
}
|
|
var isFunction_default = isFunction;
|
|
|
|
// ../node_modules/lodash-es/_coreJsData.js
|
|
var coreJsData = root_default["__core-js_shared__"];
|
|
var coreJsData_default = coreJsData;
|
|
|
|
// ../node_modules/lodash-es/_isMasked.js
|
|
var maskSrcKey = function() {
|
|
var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
|
|
return uid ? "Symbol(src)_1." + uid : "";
|
|
}();
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && maskSrcKey in func;
|
|
}
|
|
var isMasked_default = isMasked;
|
|
|
|
// ../node_modules/lodash-es/_toSource.js
|
|
var funcProto = Function.prototype;
|
|
var funcToString = funcProto.toString;
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e2) {
|
|
}
|
|
try {
|
|
return func + "";
|
|
} catch (e2) {
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
var toSource_default = toSource;
|
|
|
|
// ../node_modules/lodash-es/_baseIsNative.js
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
var funcProto2 = Function.prototype;
|
|
var objectProto3 = Object.prototype;
|
|
var funcToString2 = funcProto2.toString;
|
|
var hasOwnProperty2 = objectProto3.hasOwnProperty;
|
|
var reIsNative = RegExp(
|
|
"^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
|
|
);
|
|
function baseIsNative(value) {
|
|
if (!isObject_default(value) || isMasked_default(value)) {
|
|
return false;
|
|
}
|
|
var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
|
|
return pattern.test(toSource_default(value));
|
|
}
|
|
var baseIsNative_default = baseIsNative;
|
|
|
|
// ../node_modules/lodash-es/_getValue.js
|
|
function getValue(object, key) {
|
|
return object == null ? void 0 : object[key];
|
|
}
|
|
var getValue_default = getValue;
|
|
|
|
// ../node_modules/lodash-es/_getNative.js
|
|
function getNative(object, key) {
|
|
var value = getValue_default(object, key);
|
|
return baseIsNative_default(value) ? value : void 0;
|
|
}
|
|
var getNative_default = getNative;
|
|
|
|
// ../node_modules/lodash-es/_nativeCreate.js
|
|
var nativeCreate = getNative_default(Object, "create");
|
|
var nativeCreate_default = nativeCreate;
|
|
|
|
// ../node_modules/lodash-es/_hashClear.js
|
|
function hashClear() {
|
|
this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
|
|
this.size = 0;
|
|
}
|
|
var hashClear_default = hashClear;
|
|
|
|
// ../node_modules/lodash-es/_hashDelete.js
|
|
function hashDelete(key) {
|
|
var result = this.has(key) && delete this.__data__[key];
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
var hashDelete_default = hashDelete;
|
|
|
|
// ../node_modules/lodash-es/_hashGet.js
|
|
var HASH_UNDEFINED = "__lodash_hash_undefined__";
|
|
var objectProto4 = Object.prototype;
|
|
var hasOwnProperty3 = objectProto4.hasOwnProperty;
|
|
function hashGet(key) {
|
|
var data = this.__data__;
|
|
if (nativeCreate_default) {
|
|
var result = data[key];
|
|
return result === HASH_UNDEFINED ? void 0 : result;
|
|
}
|
|
return hasOwnProperty3.call(data, key) ? data[key] : void 0;
|
|
}
|
|
var hashGet_default = hashGet;
|
|
|
|
// ../node_modules/lodash-es/_hashHas.js
|
|
var objectProto5 = Object.prototype;
|
|
var hasOwnProperty4 = objectProto5.hasOwnProperty;
|
|
function hashHas(key) {
|
|
var data = this.__data__;
|
|
return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key);
|
|
}
|
|
var hashHas_default = hashHas;
|
|
|
|
// ../node_modules/lodash-es/_hashSet.js
|
|
var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
|
|
function hashSet(key, value) {
|
|
var data = this.__data__;
|
|
this.size += this.has(key) ? 0 : 1;
|
|
data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
|
|
return this;
|
|
}
|
|
var hashSet_default = hashSet;
|
|
|
|
// ../node_modules/lodash-es/_Hash.js
|
|
function Hash(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
Hash.prototype.clear = hashClear_default;
|
|
Hash.prototype["delete"] = hashDelete_default;
|
|
Hash.prototype.get = hashGet_default;
|
|
Hash.prototype.has = hashHas_default;
|
|
Hash.prototype.set = hashSet_default;
|
|
var Hash_default = Hash;
|
|
|
|
// ../node_modules/lodash-es/_listCacheClear.js
|
|
function listCacheClear() {
|
|
this.__data__ = [];
|
|
this.size = 0;
|
|
}
|
|
var listCacheClear_default = listCacheClear;
|
|
|
|
// ../node_modules/lodash-es/eq.js
|
|
function eq(value, other) {
|
|
return value === other || value !== value && other !== other;
|
|
}
|
|
var eq_default = eq;
|
|
|
|
// ../node_modules/lodash-es/_assocIndexOf.js
|
|
function assocIndexOf(array, key) {
|
|
var length = array.length;
|
|
while (length--) {
|
|
if (eq_default(array[length][0], key)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var assocIndexOf_default = assocIndexOf;
|
|
|
|
// ../node_modules/lodash-es/_listCacheDelete.js
|
|
var arrayProto = Array.prototype;
|
|
var splice = arrayProto.splice;
|
|
function listCacheDelete(key) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
var lastIndex = data.length - 1;
|
|
if (index == lastIndex) {
|
|
data.pop();
|
|
} else {
|
|
splice.call(data, index, 1);
|
|
}
|
|
--this.size;
|
|
return true;
|
|
}
|
|
var listCacheDelete_default = listCacheDelete;
|
|
|
|
// ../node_modules/lodash-es/_listCacheGet.js
|
|
function listCacheGet(key) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
return index < 0 ? void 0 : data[index][1];
|
|
}
|
|
var listCacheGet_default = listCacheGet;
|
|
|
|
// ../node_modules/lodash-es/_listCacheHas.js
|
|
function listCacheHas(key) {
|
|
return assocIndexOf_default(this.__data__, key) > -1;
|
|
}
|
|
var listCacheHas_default = listCacheHas;
|
|
|
|
// ../node_modules/lodash-es/_listCacheSet.js
|
|
function listCacheSet(key, value) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
++this.size;
|
|
data.push([key, value]);
|
|
} else {
|
|
data[index][1] = value;
|
|
}
|
|
return this;
|
|
}
|
|
var listCacheSet_default = listCacheSet;
|
|
|
|
// ../node_modules/lodash-es/_ListCache.js
|
|
function ListCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
ListCache.prototype.clear = listCacheClear_default;
|
|
ListCache.prototype["delete"] = listCacheDelete_default;
|
|
ListCache.prototype.get = listCacheGet_default;
|
|
ListCache.prototype.has = listCacheHas_default;
|
|
ListCache.prototype.set = listCacheSet_default;
|
|
var ListCache_default = ListCache;
|
|
|
|
// ../node_modules/lodash-es/_Map.js
|
|
var Map2 = getNative_default(root_default, "Map");
|
|
var Map_default = Map2;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheClear.js
|
|
function mapCacheClear() {
|
|
this.size = 0;
|
|
this.__data__ = {
|
|
"hash": new Hash_default(),
|
|
"map": new (Map_default || ListCache_default)(),
|
|
"string": new Hash_default()
|
|
};
|
|
}
|
|
var mapCacheClear_default = mapCacheClear;
|
|
|
|
// ../node_modules/lodash-es/_isKeyable.js
|
|
function isKeyable(value) {
|
|
var type = typeof value;
|
|
return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
|
|
}
|
|
var isKeyable_default = isKeyable;
|
|
|
|
// ../node_modules/lodash-es/_getMapData.js
|
|
function getMapData(map, key) {
|
|
var data = map.__data__;
|
|
return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
|
|
}
|
|
var getMapData_default = getMapData;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheDelete.js
|
|
function mapCacheDelete(key) {
|
|
var result = getMapData_default(this, key)["delete"](key);
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
var mapCacheDelete_default = mapCacheDelete;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheGet.js
|
|
function mapCacheGet(key) {
|
|
return getMapData_default(this, key).get(key);
|
|
}
|
|
var mapCacheGet_default = mapCacheGet;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheHas.js
|
|
function mapCacheHas(key) {
|
|
return getMapData_default(this, key).has(key);
|
|
}
|
|
var mapCacheHas_default = mapCacheHas;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheSet.js
|
|
function mapCacheSet(key, value) {
|
|
var data = getMapData_default(this, key), size = data.size;
|
|
data.set(key, value);
|
|
this.size += data.size == size ? 0 : 1;
|
|
return this;
|
|
}
|
|
var mapCacheSet_default = mapCacheSet;
|
|
|
|
// ../node_modules/lodash-es/_MapCache.js
|
|
function MapCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
MapCache.prototype.clear = mapCacheClear_default;
|
|
MapCache.prototype["delete"] = mapCacheDelete_default;
|
|
MapCache.prototype.get = mapCacheGet_default;
|
|
MapCache.prototype.has = mapCacheHas_default;
|
|
MapCache.prototype.set = mapCacheSet_default;
|
|
var MapCache_default = MapCache;
|
|
|
|
// ../node_modules/lodash-es/memoize.js
|
|
var FUNC_ERROR_TEXT = "Expected a function";
|
|
function memoize(func, resolver) {
|
|
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
var memoized = function() {
|
|
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
|
|
if (cache2.has(key)) {
|
|
return cache2.get(key);
|
|
}
|
|
var result = func.apply(this, args);
|
|
memoized.cache = cache2.set(key, result) || cache2;
|
|
return result;
|
|
};
|
|
memoized.cache = new (memoize.Cache || MapCache_default)();
|
|
return memoized;
|
|
}
|
|
memoize.Cache = MapCache_default;
|
|
var memoize_default = memoize;
|
|
|
|
// ../node_modules/lodash-es/_memoizeCapped.js
|
|
var MAX_MEMOIZE_SIZE = 500;
|
|
function memoizeCapped(func) {
|
|
var result = memoize_default(func, function(key) {
|
|
if (cache2.size === MAX_MEMOIZE_SIZE) {
|
|
cache2.clear();
|
|
}
|
|
return key;
|
|
});
|
|
var cache2 = result.cache;
|
|
return result;
|
|
}
|
|
var memoizeCapped_default = memoizeCapped;
|
|
|
|
// ../node_modules/lodash-es/_stringToPath.js
|
|
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
|
|
var reEscapeChar = /\\(\\)?/g;
|
|
var stringToPath = memoizeCapped_default(function(string2) {
|
|
var result = [];
|
|
if (string2.charCodeAt(0) === 46) {
|
|
result.push("");
|
|
}
|
|
string2.replace(rePropName, function(match, number2, quote, subString) {
|
|
result.push(quote ? subString.replace(reEscapeChar, "$1") : number2 || match);
|
|
});
|
|
return result;
|
|
});
|
|
var stringToPath_default = stringToPath;
|
|
|
|
// ../node_modules/lodash-es/_arrayMap.js
|
|
function arrayMap(array, iteratee) {
|
|
var index = -1, length = array == null ? 0 : array.length, result = Array(length);
|
|
while (++index < length) {
|
|
result[index] = iteratee(array[index], index, array);
|
|
}
|
|
return result;
|
|
}
|
|
var arrayMap_default = arrayMap;
|
|
|
|
// ../node_modules/lodash-es/_baseToString.js
|
|
var INFINITY = 1 / 0;
|
|
var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolToString = symbolProto ? symbolProto.toString : void 0;
|
|
function baseToString(value) {
|
|
if (typeof value == "string") {
|
|
return value;
|
|
}
|
|
if (isArray_default(value)) {
|
|
return arrayMap_default(value, baseToString) + "";
|
|
}
|
|
if (isSymbol_default(value)) {
|
|
return symbolToString ? symbolToString.call(value) : "";
|
|
}
|
|
var result = value + "";
|
|
return result == "0" && 1 / value == -INFINITY ? "-0" : result;
|
|
}
|
|
var baseToString_default = baseToString;
|
|
|
|
// ../node_modules/lodash-es/toString.js
|
|
function toString(value) {
|
|
return value == null ? "" : baseToString_default(value);
|
|
}
|
|
var toString_default = toString;
|
|
|
|
// ../node_modules/lodash-es/_castPath.js
|
|
function castPath(value, object) {
|
|
if (isArray_default(value)) {
|
|
return value;
|
|
}
|
|
return isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
|
|
}
|
|
var castPath_default = castPath;
|
|
|
|
// ../node_modules/lodash-es/_toKey.js
|
|
var INFINITY2 = 1 / 0;
|
|
function toKey(value) {
|
|
if (typeof value == "string" || isSymbol_default(value)) {
|
|
return value;
|
|
}
|
|
var result = value + "";
|
|
return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
|
|
}
|
|
var toKey_default = toKey;
|
|
|
|
// ../node_modules/lodash-es/_baseGet.js
|
|
function baseGet(object, path) {
|
|
path = castPath_default(path, object);
|
|
var index = 0, length = path.length;
|
|
while (object != null && index < length) {
|
|
object = object[toKey_default(path[index++])];
|
|
}
|
|
return index && index == length ? object : void 0;
|
|
}
|
|
var baseGet_default = baseGet;
|
|
|
|
// ../node_modules/lodash-es/get.js
|
|
function get(object, path, defaultValue) {
|
|
var result = object == null ? void 0 : baseGet_default(object, path);
|
|
return result === void 0 ? defaultValue : result;
|
|
}
|
|
var get_default = get;
|
|
|
|
// shared/src/utils/getDeep.ts
|
|
function getDeep(v2, path) {
|
|
if (path.length === 0)
|
|
return v2;
|
|
return get_default(v2, path);
|
|
}
|
|
|
|
// shared/src/utils/SimpleCache.ts
|
|
var SimpleCache = class {
|
|
constructor() {
|
|
/**
|
|
* NOTE this could also be a Map.
|
|
*/
|
|
__publicField(this, "_values", {});
|
|
}
|
|
/**
|
|
* get the cache item at `key` or produce it using `producer` and cache _that_.
|
|
*
|
|
* Note that this won't work if you change the producer, like `get(key, producer1); get(key, producer2)`.
|
|
*/
|
|
get(key, producer) {
|
|
if (this.has(key)) {
|
|
return this._values[key];
|
|
} else {
|
|
const cachedValue = producer();
|
|
this._values[key] = cachedValue;
|
|
return cachedValue;
|
|
}
|
|
}
|
|
/**
|
|
* Returns true if the cache has an item at `key`.
|
|
*/
|
|
has(key) {
|
|
return this._values.hasOwnProperty(key);
|
|
}
|
|
};
|
|
|
|
// core/src/sheetObjects/SheetObjectTemplate.ts
|
|
var import_dataverse6 = require("@theatre/dataverse");
|
|
|
|
// ../node_modules/lodash-es/_defineProperty.js
|
|
var defineProperty = function() {
|
|
try {
|
|
var func = getNative_default(Object, "defineProperty");
|
|
func({}, "", {});
|
|
return func;
|
|
} catch (e2) {
|
|
}
|
|
}();
|
|
var defineProperty_default = defineProperty;
|
|
|
|
// ../node_modules/lodash-es/_baseAssignValue.js
|
|
function baseAssignValue(object, key, value) {
|
|
if (key == "__proto__" && defineProperty_default) {
|
|
defineProperty_default(object, key, {
|
|
"configurable": true,
|
|
"enumerable": true,
|
|
"value": value,
|
|
"writable": true
|
|
});
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
var baseAssignValue_default = baseAssignValue;
|
|
|
|
// ../node_modules/lodash-es/_assignValue.js
|
|
var objectProto6 = Object.prototype;
|
|
var hasOwnProperty5 = objectProto6.hasOwnProperty;
|
|
function assignValue(object, key, value) {
|
|
var objValue = object[key];
|
|
if (!(hasOwnProperty5.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) {
|
|
baseAssignValue_default(object, key, value);
|
|
}
|
|
}
|
|
var assignValue_default = assignValue;
|
|
|
|
// ../node_modules/lodash-es/_isIndex.js
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
function isIndex(value, length) {
|
|
var type = typeof value;
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
var isIndex_default = isIndex;
|
|
|
|
// ../node_modules/lodash-es/_baseSet.js
|
|
function baseSet(object, path, value, customizer) {
|
|
if (!isObject_default(object)) {
|
|
return object;
|
|
}
|
|
path = castPath_default(path, object);
|
|
var index = -1, length = path.length, lastIndex = length - 1, nested = object;
|
|
while (nested != null && ++index < length) {
|
|
var key = toKey_default(path[index]), newValue = value;
|
|
if (key === "__proto__" || key === "constructor" || key === "prototype") {
|
|
return object;
|
|
}
|
|
if (index != lastIndex) {
|
|
var objValue = nested[key];
|
|
newValue = customizer ? customizer(objValue, key, nested) : void 0;
|
|
if (newValue === void 0) {
|
|
newValue = isObject_default(objValue) ? objValue : isIndex_default(path[index + 1]) ? [] : {};
|
|
}
|
|
}
|
|
assignValue_default(nested, key, newValue);
|
|
nested = nested[key];
|
|
}
|
|
return object;
|
|
}
|
|
var baseSet_default = baseSet;
|
|
|
|
// ../node_modules/lodash-es/set.js
|
|
function set(object, path, value) {
|
|
return object == null ? object : baseSet_default(object, path, value);
|
|
}
|
|
var set_default = set;
|
|
|
|
// core/src/sheetObjects/getPropDefaultsOfSheetObject.ts
|
|
var cachedDefaults = /* @__PURE__ */ new WeakMap();
|
|
function getPropDefaultsOfSheetObject(config) {
|
|
return getDefaultsOfPropTypeConfig(config);
|
|
}
|
|
function getDefaultsOfPropTypeConfig(config) {
|
|
if (cachedDefaults.has(config)) {
|
|
return cachedDefaults.get(config);
|
|
}
|
|
const generated = config.type === "compound" ? generateDefaultsForCompound(config) : config.type === "enum" ? generateDefaultsForEnum(config) : config.default;
|
|
cachedDefaults.set(config, generated);
|
|
return generated;
|
|
}
|
|
function generateDefaultsForEnum(config) {
|
|
const defaults = {
|
|
$case: config.defaultCase
|
|
};
|
|
for (const [case_, caseConf] of Object.entries(config.cases)) {
|
|
defaults[case_] = getDefaultsOfPropTypeConfig(caseConf);
|
|
}
|
|
return defaults;
|
|
}
|
|
function generateDefaultsForCompound(config) {
|
|
const defaults = {};
|
|
for (const [key, propConf] of Object.entries(config.props)) {
|
|
defaults[key] = getDefaultsOfPropTypeConfig(propConf);
|
|
}
|
|
return defaults;
|
|
}
|
|
|
|
// core/src/sequences/interpolationTripleAtPosition.ts
|
|
var import_dataverse2 = require("@theatre/dataverse");
|
|
var import_UnitBezier = __toESM(require_UnitBezier());
|
|
function interpolationTripleAtPosition(ctx, trackP, timeD) {
|
|
return (0, import_dataverse2.prism)(() => {
|
|
const track = (0, import_dataverse2.val)(trackP);
|
|
const driverD = import_dataverse2.prism.memo(
|
|
"driver",
|
|
() => {
|
|
if (!track) {
|
|
return (0, import_dataverse2.prism)(() => void 0);
|
|
} else if (track.type === "BasicKeyframedTrack") {
|
|
return _forKeyframedTrack(ctx, track, timeD);
|
|
} else {
|
|
ctx.logger.error("Track type not yet supported.");
|
|
return (0, import_dataverse2.prism)(() => void 0);
|
|
}
|
|
},
|
|
[track]
|
|
);
|
|
return driverD.getValue();
|
|
});
|
|
}
|
|
function _forKeyframedTrack(ctx, track, timeD) {
|
|
return (0, import_dataverse2.prism)(() => {
|
|
let stateRef = import_dataverse2.prism.ref("state", { started: false });
|
|
let state = stateRef.current;
|
|
const time = timeD.getValue();
|
|
if (!state.started || time < state.validFrom || state.validTo <= time) {
|
|
stateRef.current = state = updateState(ctx, timeD, track);
|
|
}
|
|
return state.der.getValue();
|
|
});
|
|
}
|
|
var undefinedConstD = (0, import_dataverse2.prism)(() => void 0);
|
|
function updateState(ctx, progressionD, track) {
|
|
const progression = progressionD.getValue();
|
|
if (track.keyframes.length === 0) {
|
|
return {
|
|
started: true,
|
|
validFrom: -Infinity,
|
|
validTo: Infinity,
|
|
der: undefinedConstD
|
|
};
|
|
}
|
|
let currentKeyframeIndex = 0;
|
|
while (true) {
|
|
const currentKeyframe = track.keyframes[currentKeyframeIndex];
|
|
if (!currentKeyframe) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
ctx.logger.error("Bug here");
|
|
}
|
|
return states.error;
|
|
}
|
|
const isLastKeyframe = currentKeyframeIndex === track.keyframes.length - 1;
|
|
if (progression < currentKeyframe.position) {
|
|
if (currentKeyframeIndex === 0) {
|
|
return states.beforeFirstKeyframe(currentKeyframe);
|
|
} else {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
ctx.logger.error("Bug here");
|
|
}
|
|
return states.error;
|
|
}
|
|
} else if (currentKeyframe.position === progression) {
|
|
if (isLastKeyframe) {
|
|
return states.lastKeyframe(currentKeyframe);
|
|
} else {
|
|
return states.between(
|
|
currentKeyframe,
|
|
track.keyframes[currentKeyframeIndex + 1],
|
|
progressionD
|
|
);
|
|
}
|
|
} else {
|
|
if (currentKeyframeIndex === track.keyframes.length - 1) {
|
|
return states.lastKeyframe(currentKeyframe);
|
|
} else {
|
|
const nextKeyframeIndex = currentKeyframeIndex + 1;
|
|
if (track.keyframes[nextKeyframeIndex].position <= progression) {
|
|
currentKeyframeIndex = nextKeyframeIndex;
|
|
continue;
|
|
} else {
|
|
return states.between(
|
|
currentKeyframe,
|
|
track.keyframes[currentKeyframeIndex + 1],
|
|
progressionD
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var states = {
|
|
beforeFirstKeyframe(kf) {
|
|
return {
|
|
started: true,
|
|
validFrom: -Infinity,
|
|
validTo: kf.position,
|
|
der: (0, import_dataverse2.prism)(() => ({ left: kf.value, progression: 0 }))
|
|
};
|
|
},
|
|
lastKeyframe(kf) {
|
|
return {
|
|
started: true,
|
|
validFrom: kf.position,
|
|
validTo: Infinity,
|
|
der: (0, import_dataverse2.prism)(() => ({ left: kf.value, progression: 0 }))
|
|
};
|
|
},
|
|
between(left, right, progressionD) {
|
|
if (!left.connectedRight) {
|
|
return {
|
|
started: true,
|
|
validFrom: left.position,
|
|
validTo: right.position,
|
|
der: (0, import_dataverse2.prism)(() => ({ left: left.value, progression: 0 }))
|
|
};
|
|
}
|
|
const globalProgressionToLocalProgression = (globalProgression) => {
|
|
return (globalProgression - left.position) / (right.position - left.position);
|
|
};
|
|
if (!left.type || left.type === "bezier") {
|
|
const solver = new import_UnitBezier.default(
|
|
left.handles[2],
|
|
left.handles[3],
|
|
right.handles[0],
|
|
right.handles[1]
|
|
);
|
|
const bezierDer = (0, import_dataverse2.prism)(() => {
|
|
const progression = globalProgressionToLocalProgression(
|
|
progressionD.getValue()
|
|
);
|
|
const valueProgression = solver.solveSimple(progression);
|
|
return {
|
|
left: left.value,
|
|
right: right.value,
|
|
progression: valueProgression
|
|
};
|
|
});
|
|
return {
|
|
started: true,
|
|
validFrom: left.position,
|
|
validTo: right.position,
|
|
der: bezierDer
|
|
};
|
|
}
|
|
const holdDer = (0, import_dataverse2.prism)(() => {
|
|
const progression = globalProgressionToLocalProgression(
|
|
progressionD.getValue()
|
|
);
|
|
const valueProgression = Math.floor(progression);
|
|
return {
|
|
left: left.value,
|
|
right: right.value,
|
|
progression: valueProgression
|
|
};
|
|
});
|
|
return {
|
|
started: true,
|
|
validFrom: left.position,
|
|
validTo: right.position,
|
|
der: holdDer
|
|
};
|
|
},
|
|
error: {
|
|
started: true,
|
|
validFrom: -Infinity,
|
|
validTo: Infinity,
|
|
der: undefinedConstD
|
|
}
|
|
};
|
|
|
|
// shared/src/utils/deepMergeWithCache.ts
|
|
function deepMergeWithCache(base, override, cache2) {
|
|
const _cache = cache2;
|
|
const possibleCachedValue = _cache.get(base);
|
|
if (possibleCachedValue && possibleCachedValue.override === override) {
|
|
return possibleCachedValue.merged;
|
|
}
|
|
const merged = __spreadValues({}, base);
|
|
for (const key of Object.keys(override)) {
|
|
const valueInOverride = override[key];
|
|
const valueInBase = base[key];
|
|
merged[key] = typeof valueInOverride === "object" && typeof valueInBase === "object" ? deepMergeWithCache(
|
|
valueInBase,
|
|
valueInOverride,
|
|
cache2
|
|
) : valueInOverride === void 0 ? valueInBase : valueInOverride;
|
|
}
|
|
cache2.set(base, { override, merged });
|
|
return merged;
|
|
}
|
|
|
|
// shared/src/utils/pointerDeep.ts
|
|
function pointerDeep(base, toAppend) {
|
|
let p2 = base;
|
|
for (const k2 of toAppend) {
|
|
p2 = p2[k2];
|
|
}
|
|
return p2;
|
|
}
|
|
|
|
// shared/src/utils/valToAtom.ts
|
|
var import_dataverse3 = require("@theatre/dataverse");
|
|
var valToAtom = (key, vals) => {
|
|
const a2 = import_dataverse3.prism.memo(key, () => new import_dataverse3.Atom(vals), []);
|
|
a2.set(vals);
|
|
return a2;
|
|
};
|
|
|
|
// core/src/sheetObjects/SheetObject.ts
|
|
var import_dataverse5 = require("@theatre/dataverse");
|
|
|
|
// core/src/sheetObjects/TheatreSheetObject.ts
|
|
var import_dataverse4 = require("@theatre/dataverse");
|
|
|
|
// ../node_modules/lodash-es/_trimmedEndIndex.js
|
|
var reWhitespace = /\s/;
|
|
function trimmedEndIndex(string2) {
|
|
var index = string2.length;
|
|
while (index-- && reWhitespace.test(string2.charAt(index))) {
|
|
}
|
|
return index;
|
|
}
|
|
var trimmedEndIndex_default = trimmedEndIndex;
|
|
|
|
// ../node_modules/lodash-es/_baseTrim.js
|
|
var reTrimStart = /^\s+/;
|
|
function baseTrim(string2) {
|
|
return string2 ? string2.slice(0, trimmedEndIndex_default(string2) + 1).replace(reTrimStart, "") : string2;
|
|
}
|
|
var baseTrim_default = baseTrim;
|
|
|
|
// ../node_modules/lodash-es/toNumber.js
|
|
var NAN = 0 / 0;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var freeParseInt = parseInt;
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol_default(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject_default(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject_default(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = baseTrim_default(value);
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
|
}
|
|
var toNumber_default = toNumber;
|
|
|
|
// ../node_modules/lodash-es/toFinite.js
|
|
var INFINITY3 = 1 / 0;
|
|
var MAX_INTEGER = 17976931348623157e292;
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber_default(value);
|
|
if (value === INFINITY3 || value === -INFINITY3) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
var toFinite_default = toFinite;
|
|
|
|
// ../node_modules/lodash-es/toInteger.js
|
|
function toInteger(value) {
|
|
var result = toFinite_default(value), remainder = result % 1;
|
|
return result === result ? remainder ? result - remainder : result : 0;
|
|
}
|
|
var toInteger_default = toInteger;
|
|
|
|
// ../node_modules/lodash-es/identity.js
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
var identity_default = identity;
|
|
|
|
// ../node_modules/lodash-es/_WeakMap.js
|
|
var WeakMap2 = getNative_default(root_default, "WeakMap");
|
|
var WeakMap_default = WeakMap2;
|
|
|
|
// ../node_modules/lodash-es/_baseCreate.js
|
|
var objectCreate = Object.create;
|
|
var baseCreate = function() {
|
|
function object() {
|
|
}
|
|
return function(proto) {
|
|
if (!isObject_default(proto)) {
|
|
return {};
|
|
}
|
|
if (objectCreate) {
|
|
return objectCreate(proto);
|
|
}
|
|
object.prototype = proto;
|
|
var result = new object();
|
|
object.prototype = void 0;
|
|
return result;
|
|
};
|
|
}();
|
|
var baseCreate_default = baseCreate;
|
|
|
|
// ../node_modules/lodash-es/_copyArray.js
|
|
function copyArray(source, array) {
|
|
var index = -1, length = source.length;
|
|
array || (array = Array(length));
|
|
while (++index < length) {
|
|
array[index] = source[index];
|
|
}
|
|
return array;
|
|
}
|
|
var copyArray_default = copyArray;
|
|
|
|
// ../node_modules/lodash-es/_arrayEach.js
|
|
function arrayEach(array, iteratee) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (iteratee(array[index], index, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
var arrayEach_default = arrayEach;
|
|
|
|
// ../node_modules/lodash-es/_copyObject.js
|
|
function copyObject(source, props, object, customizer) {
|
|
var isNew = !object;
|
|
object || (object = {});
|
|
var index = -1, length = props.length;
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
|
|
if (newValue === void 0) {
|
|
newValue = source[key];
|
|
}
|
|
if (isNew) {
|
|
baseAssignValue_default(object, key, newValue);
|
|
} else {
|
|
assignValue_default(object, key, newValue);
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
var copyObject_default = copyObject;
|
|
|
|
// ../node_modules/lodash-es/isLength.js
|
|
var MAX_SAFE_INTEGER2 = 9007199254740991;
|
|
function isLength(value) {
|
|
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
|
|
}
|
|
var isLength_default = isLength;
|
|
|
|
// ../node_modules/lodash-es/isArrayLike.js
|
|
function isArrayLike(value) {
|
|
return value != null && isLength_default(value.length) && !isFunction_default(value);
|
|
}
|
|
var isArrayLike_default = isArrayLike;
|
|
|
|
// ../node_modules/lodash-es/_isPrototype.js
|
|
var objectProto7 = Object.prototype;
|
|
function isPrototype(value) {
|
|
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto7;
|
|
return value === proto;
|
|
}
|
|
var isPrototype_default = isPrototype;
|
|
|
|
// ../node_modules/lodash-es/_baseTimes.js
|
|
function baseTimes(n2, iteratee) {
|
|
var index = -1, result = Array(n2);
|
|
while (++index < n2) {
|
|
result[index] = iteratee(index);
|
|
}
|
|
return result;
|
|
}
|
|
var baseTimes_default = baseTimes;
|
|
|
|
// ../node_modules/lodash-es/_baseIsArguments.js
|
|
var argsTag = "[object Arguments]";
|
|
function baseIsArguments(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
|
|
}
|
|
var baseIsArguments_default = baseIsArguments;
|
|
|
|
// ../node_modules/lodash-es/isArguments.js
|
|
var objectProto8 = Object.prototype;
|
|
var hasOwnProperty6 = objectProto8.hasOwnProperty;
|
|
var propertyIsEnumerable = objectProto8.propertyIsEnumerable;
|
|
var isArguments = baseIsArguments_default(function() {
|
|
return arguments;
|
|
}()) ? baseIsArguments_default : function(value) {
|
|
return isObjectLike_default(value) && hasOwnProperty6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
|
|
};
|
|
var isArguments_default = isArguments;
|
|
|
|
// ../node_modules/lodash-es/stubFalse.js
|
|
function stubFalse() {
|
|
return false;
|
|
}
|
|
var stubFalse_default = stubFalse;
|
|
|
|
// ../node_modules/lodash-es/isBuffer.js
|
|
var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
var Buffer2 = moduleExports ? root_default.Buffer : void 0;
|
|
var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
|
|
var isBuffer = nativeIsBuffer || stubFalse_default;
|
|
var isBuffer_default = isBuffer;
|
|
|
|
// ../node_modules/lodash-es/_baseIsTypedArray.js
|
|
var argsTag2 = "[object Arguments]";
|
|
var arrayTag = "[object Array]";
|
|
var boolTag = "[object Boolean]";
|
|
var dateTag = "[object Date]";
|
|
var errorTag = "[object Error]";
|
|
var funcTag2 = "[object Function]";
|
|
var mapTag = "[object Map]";
|
|
var numberTag = "[object Number]";
|
|
var objectTag = "[object Object]";
|
|
var regexpTag = "[object RegExp]";
|
|
var setTag = "[object Set]";
|
|
var stringTag = "[object String]";
|
|
var weakMapTag = "[object WeakMap]";
|
|
var arrayBufferTag = "[object ArrayBuffer]";
|
|
var dataViewTag = "[object DataView]";
|
|
var float32Tag = "[object Float32Array]";
|
|
var float64Tag = "[object Float64Array]";
|
|
var int8Tag = "[object Int8Array]";
|
|
var int16Tag = "[object Int16Array]";
|
|
var int32Tag = "[object Int32Array]";
|
|
var uint8Tag = "[object Uint8Array]";
|
|
var uint8ClampedTag = "[object Uint8ClampedArray]";
|
|
var uint16Tag = "[object Uint16Array]";
|
|
var uint32Tag = "[object Uint32Array]";
|
|
var typedArrayTags = {};
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
|
|
typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
|
function baseIsTypedArray(value) {
|
|
return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
|
|
}
|
|
var baseIsTypedArray_default = baseIsTypedArray;
|
|
|
|
// ../node_modules/lodash-es/_baseUnary.js
|
|
function baseUnary(func) {
|
|
return function(value) {
|
|
return func(value);
|
|
};
|
|
}
|
|
var baseUnary_default = baseUnary;
|
|
|
|
// ../node_modules/lodash-es/_nodeUtil.js
|
|
var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
|
|
var freeProcess = moduleExports2 && freeGlobal_default.process;
|
|
var nodeUtil = function() {
|
|
try {
|
|
var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
|
|
if (types) {
|
|
return types;
|
|
}
|
|
return freeProcess && freeProcess.binding && freeProcess.binding("util");
|
|
} catch (e2) {
|
|
}
|
|
}();
|
|
var nodeUtil_default = nodeUtil;
|
|
|
|
// ../node_modules/lodash-es/isTypedArray.js
|
|
var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
|
|
var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
|
|
var isTypedArray_default = isTypedArray;
|
|
|
|
// ../node_modules/lodash-es/_arrayLikeKeys.js
|
|
var objectProto9 = Object.prototype;
|
|
var hasOwnProperty7 = objectProto9.hasOwnProperty;
|
|
function arrayLikeKeys(value, inherited) {
|
|
var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
|
|
for (var key in value) {
|
|
if ((inherited || hasOwnProperty7.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
|
|
(key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
|
|
isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
|
|
isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
|
|
isIndex_default(key, length)))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var arrayLikeKeys_default = arrayLikeKeys;
|
|
|
|
// ../node_modules/lodash-es/_overArg.js
|
|
function overArg(func, transform) {
|
|
return function(arg) {
|
|
return func(transform(arg));
|
|
};
|
|
}
|
|
var overArg_default = overArg;
|
|
|
|
// ../node_modules/lodash-es/_nativeKeys.js
|
|
var nativeKeys = overArg_default(Object.keys, Object);
|
|
var nativeKeys_default = nativeKeys;
|
|
|
|
// ../node_modules/lodash-es/_baseKeys.js
|
|
var objectProto10 = Object.prototype;
|
|
var hasOwnProperty8 = objectProto10.hasOwnProperty;
|
|
function baseKeys(object) {
|
|
if (!isPrototype_default(object)) {
|
|
return nativeKeys_default(object);
|
|
}
|
|
var result = [];
|
|
for (var key in Object(object)) {
|
|
if (hasOwnProperty8.call(object, key) && key != "constructor") {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var baseKeys_default = baseKeys;
|
|
|
|
// ../node_modules/lodash-es/keys.js
|
|
function keys(object) {
|
|
return isArrayLike_default(object) ? arrayLikeKeys_default(object) : baseKeys_default(object);
|
|
}
|
|
var keys_default = keys;
|
|
|
|
// ../node_modules/lodash-es/_nativeKeysIn.js
|
|
function nativeKeysIn(object) {
|
|
var result = [];
|
|
if (object != null) {
|
|
for (var key in Object(object)) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var nativeKeysIn_default = nativeKeysIn;
|
|
|
|
// ../node_modules/lodash-es/_baseKeysIn.js
|
|
var objectProto11 = Object.prototype;
|
|
var hasOwnProperty9 = objectProto11.hasOwnProperty;
|
|
function baseKeysIn(object) {
|
|
if (!isObject_default(object)) {
|
|
return nativeKeysIn_default(object);
|
|
}
|
|
var isProto = isPrototype_default(object), result = [];
|
|
for (var key in object) {
|
|
if (!(key == "constructor" && (isProto || !hasOwnProperty9.call(object, key)))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var baseKeysIn_default = baseKeysIn;
|
|
|
|
// ../node_modules/lodash-es/keysIn.js
|
|
function keysIn(object) {
|
|
return isArrayLike_default(object) ? arrayLikeKeys_default(object, true) : baseKeysIn_default(object);
|
|
}
|
|
var keysIn_default = keysIn;
|
|
|
|
// ../node_modules/lodash-es/_arrayPush.js
|
|
function arrayPush(array, values) {
|
|
var index = -1, length = values.length, offset = array.length;
|
|
while (++index < length) {
|
|
array[offset + index] = values[index];
|
|
}
|
|
return array;
|
|
}
|
|
var arrayPush_default = arrayPush;
|
|
|
|
// ../node_modules/lodash-es/_getPrototype.js
|
|
var getPrototype = overArg_default(Object.getPrototypeOf, Object);
|
|
var getPrototype_default = getPrototype;
|
|
|
|
// ../node_modules/lodash-es/isPlainObject.js
|
|
var objectTag2 = "[object Object]";
|
|
var funcProto3 = Function.prototype;
|
|
var objectProto12 = Object.prototype;
|
|
var funcToString3 = funcProto3.toString;
|
|
var hasOwnProperty10 = objectProto12.hasOwnProperty;
|
|
var objectCtorString = funcToString3.call(Object);
|
|
function isPlainObject(value) {
|
|
if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag2) {
|
|
return false;
|
|
}
|
|
var proto = getPrototype_default(value);
|
|
if (proto === null) {
|
|
return true;
|
|
}
|
|
var Ctor = hasOwnProperty10.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
|
|
}
|
|
var isPlainObject_default = isPlainObject;
|
|
|
|
// ../node_modules/lodash-es/_baseSlice.js
|
|
function baseSlice(array, start, end) {
|
|
var index = -1, length = array.length;
|
|
if (start < 0) {
|
|
start = -start > length ? 0 : length + start;
|
|
}
|
|
end = end > length ? length : end;
|
|
if (end < 0) {
|
|
end += length;
|
|
}
|
|
length = start > end ? 0 : end - start >>> 0;
|
|
start >>>= 0;
|
|
var result = Array(length);
|
|
while (++index < length) {
|
|
result[index] = array[index + start];
|
|
}
|
|
return result;
|
|
}
|
|
var baseSlice_default = baseSlice;
|
|
|
|
// ../node_modules/lodash-es/_castSlice.js
|
|
function castSlice(array, start, end) {
|
|
var length = array.length;
|
|
end = end === void 0 ? length : end;
|
|
return !start && end >= length ? array : baseSlice_default(array, start, end);
|
|
}
|
|
var castSlice_default = castSlice;
|
|
|
|
// ../node_modules/lodash-es/_hasUnicode.js
|
|
var rsAstralRange = "\\ud800-\\udfff";
|
|
var rsComboMarksRange = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange = "\\u20d0-\\u20ff";
|
|
var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
|
|
var rsVarRange = "\\ufe0e\\ufe0f";
|
|
var rsZWJ = "\\u200d";
|
|
var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
|
|
function hasUnicode(string2) {
|
|
return reHasUnicode.test(string2);
|
|
}
|
|
var hasUnicode_default = hasUnicode;
|
|
|
|
// ../node_modules/lodash-es/_asciiToArray.js
|
|
function asciiToArray(string2) {
|
|
return string2.split("");
|
|
}
|
|
var asciiToArray_default = asciiToArray;
|
|
|
|
// ../node_modules/lodash-es/_unicodeToArray.js
|
|
var rsAstralRange2 = "\\ud800-\\udfff";
|
|
var rsComboMarksRange2 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
|
|
var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
|
|
var rsVarRange2 = "\\ufe0e\\ufe0f";
|
|
var rsAstral = "[" + rsAstralRange2 + "]";
|
|
var rsCombo = "[" + rsComboRange2 + "]";
|
|
var rsFitz = "\\ud83c[\\udffb-\\udfff]";
|
|
var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
|
|
var rsNonAstral = "[^" + rsAstralRange2 + "]";
|
|
var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
var rsZWJ2 = "\\u200d";
|
|
var reOptMod = rsModifier + "?";
|
|
var rsOptVar = "[" + rsVarRange2 + "]?";
|
|
var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
|
|
var rsSeq = rsOptVar + reOptMod + rsOptJoin;
|
|
var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
|
|
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
|
|
function unicodeToArray(string2) {
|
|
return string2.match(reUnicode) || [];
|
|
}
|
|
var unicodeToArray_default = unicodeToArray;
|
|
|
|
// ../node_modules/lodash-es/_stringToArray.js
|
|
function stringToArray(string2) {
|
|
return hasUnicode_default(string2) ? unicodeToArray_default(string2) : asciiToArray_default(string2);
|
|
}
|
|
var stringToArray_default = stringToArray;
|
|
|
|
// ../node_modules/lodash-es/_baseClamp.js
|
|
function baseClamp(number2, lower, upper) {
|
|
if (number2 === number2) {
|
|
if (upper !== void 0) {
|
|
number2 = number2 <= upper ? number2 : upper;
|
|
}
|
|
if (lower !== void 0) {
|
|
number2 = number2 >= lower ? number2 : lower;
|
|
}
|
|
}
|
|
return number2;
|
|
}
|
|
var baseClamp_default = baseClamp;
|
|
|
|
// ../node_modules/lodash-es/clamp.js
|
|
function clamp(number2, lower, upper) {
|
|
if (upper === void 0) {
|
|
upper = lower;
|
|
lower = void 0;
|
|
}
|
|
if (upper !== void 0) {
|
|
upper = toNumber_default(upper);
|
|
upper = upper === upper ? upper : 0;
|
|
}
|
|
if (lower !== void 0) {
|
|
lower = toNumber_default(lower);
|
|
lower = lower === lower ? lower : 0;
|
|
}
|
|
return baseClamp_default(toNumber_default(number2), lower, upper);
|
|
}
|
|
var clamp_default = clamp;
|
|
|
|
// ../node_modules/lodash-es/_stackClear.js
|
|
function stackClear() {
|
|
this.__data__ = new ListCache_default();
|
|
this.size = 0;
|
|
}
|
|
var stackClear_default = stackClear;
|
|
|
|
// ../node_modules/lodash-es/_stackDelete.js
|
|
function stackDelete(key) {
|
|
var data = this.__data__, result = data["delete"](key);
|
|
this.size = data.size;
|
|
return result;
|
|
}
|
|
var stackDelete_default = stackDelete;
|
|
|
|
// ../node_modules/lodash-es/_stackGet.js
|
|
function stackGet(key) {
|
|
return this.__data__.get(key);
|
|
}
|
|
var stackGet_default = stackGet;
|
|
|
|
// ../node_modules/lodash-es/_stackHas.js
|
|
function stackHas(key) {
|
|
return this.__data__.has(key);
|
|
}
|
|
var stackHas_default = stackHas;
|
|
|
|
// ../node_modules/lodash-es/_stackSet.js
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
function stackSet(key, value) {
|
|
var data = this.__data__;
|
|
if (data instanceof ListCache_default) {
|
|
var pairs = data.__data__;
|
|
if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
|
|
pairs.push([key, value]);
|
|
this.size = ++data.size;
|
|
return this;
|
|
}
|
|
data = this.__data__ = new MapCache_default(pairs);
|
|
}
|
|
data.set(key, value);
|
|
this.size = data.size;
|
|
return this;
|
|
}
|
|
var stackSet_default = stackSet;
|
|
|
|
// ../node_modules/lodash-es/_Stack.js
|
|
function Stack(entries) {
|
|
var data = this.__data__ = new ListCache_default(entries);
|
|
this.size = data.size;
|
|
}
|
|
Stack.prototype.clear = stackClear_default;
|
|
Stack.prototype["delete"] = stackDelete_default;
|
|
Stack.prototype.get = stackGet_default;
|
|
Stack.prototype.has = stackHas_default;
|
|
Stack.prototype.set = stackSet_default;
|
|
var Stack_default = Stack;
|
|
|
|
// ../node_modules/lodash-es/_baseAssign.js
|
|
function baseAssign(object, source) {
|
|
return object && copyObject_default(source, keys_default(source), object);
|
|
}
|
|
var baseAssign_default = baseAssign;
|
|
|
|
// ../node_modules/lodash-es/_baseAssignIn.js
|
|
function baseAssignIn(object, source) {
|
|
return object && copyObject_default(source, keysIn_default(source), object);
|
|
}
|
|
var baseAssignIn_default = baseAssignIn;
|
|
|
|
// ../node_modules/lodash-es/_cloneBuffer.js
|
|
var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
|
|
var Buffer3 = moduleExports3 ? root_default.Buffer : void 0;
|
|
var allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : void 0;
|
|
function cloneBuffer(buffer, isDeep) {
|
|
if (isDeep) {
|
|
return buffer.slice();
|
|
}
|
|
var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
|
|
buffer.copy(result);
|
|
return result;
|
|
}
|
|
var cloneBuffer_default = cloneBuffer;
|
|
|
|
// ../node_modules/lodash-es/_arrayFilter.js
|
|
function arrayFilter(array, predicate) {
|
|
var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (predicate(value, index, array)) {
|
|
result[resIndex++] = value;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var arrayFilter_default = arrayFilter;
|
|
|
|
// ../node_modules/lodash-es/stubArray.js
|
|
function stubArray() {
|
|
return [];
|
|
}
|
|
var stubArray_default = stubArray;
|
|
|
|
// ../node_modules/lodash-es/_getSymbols.js
|
|
var objectProto13 = Object.prototype;
|
|
var propertyIsEnumerable2 = objectProto13.propertyIsEnumerable;
|
|
var nativeGetSymbols = Object.getOwnPropertySymbols;
|
|
var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
|
|
if (object == null) {
|
|
return [];
|
|
}
|
|
object = Object(object);
|
|
return arrayFilter_default(nativeGetSymbols(object), function(symbol) {
|
|
return propertyIsEnumerable2.call(object, symbol);
|
|
});
|
|
};
|
|
var getSymbols_default = getSymbols;
|
|
|
|
// ../node_modules/lodash-es/_copySymbols.js
|
|
function copySymbols(source, object) {
|
|
return copyObject_default(source, getSymbols_default(source), object);
|
|
}
|
|
var copySymbols_default = copySymbols;
|
|
|
|
// ../node_modules/lodash-es/_getSymbolsIn.js
|
|
var nativeGetSymbols2 = Object.getOwnPropertySymbols;
|
|
var getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object) {
|
|
var result = [];
|
|
while (object) {
|
|
arrayPush_default(result, getSymbols_default(object));
|
|
object = getPrototype_default(object);
|
|
}
|
|
return result;
|
|
};
|
|
var getSymbolsIn_default = getSymbolsIn;
|
|
|
|
// ../node_modules/lodash-es/_copySymbolsIn.js
|
|
function copySymbolsIn(source, object) {
|
|
return copyObject_default(source, getSymbolsIn_default(source), object);
|
|
}
|
|
var copySymbolsIn_default = copySymbolsIn;
|
|
|
|
// ../node_modules/lodash-es/_baseGetAllKeys.js
|
|
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
|
|
var result = keysFunc(object);
|
|
return isArray_default(object) ? result : arrayPush_default(result, symbolsFunc(object));
|
|
}
|
|
var baseGetAllKeys_default = baseGetAllKeys;
|
|
|
|
// ../node_modules/lodash-es/_getAllKeys.js
|
|
function getAllKeys(object) {
|
|
return baseGetAllKeys_default(object, keys_default, getSymbols_default);
|
|
}
|
|
var getAllKeys_default = getAllKeys;
|
|
|
|
// ../node_modules/lodash-es/_getAllKeysIn.js
|
|
function getAllKeysIn(object) {
|
|
return baseGetAllKeys_default(object, keysIn_default, getSymbolsIn_default);
|
|
}
|
|
var getAllKeysIn_default = getAllKeysIn;
|
|
|
|
// ../node_modules/lodash-es/_DataView.js
|
|
var DataView = getNative_default(root_default, "DataView");
|
|
var DataView_default = DataView;
|
|
|
|
// ../node_modules/lodash-es/_Promise.js
|
|
var Promise2 = getNative_default(root_default, "Promise");
|
|
var Promise_default = Promise2;
|
|
|
|
// ../node_modules/lodash-es/_Set.js
|
|
var Set2 = getNative_default(root_default, "Set");
|
|
var Set_default = Set2;
|
|
|
|
// ../node_modules/lodash-es/_getTag.js
|
|
var mapTag2 = "[object Map]";
|
|
var objectTag3 = "[object Object]";
|
|
var promiseTag = "[object Promise]";
|
|
var setTag2 = "[object Set]";
|
|
var weakMapTag2 = "[object WeakMap]";
|
|
var dataViewTag2 = "[object DataView]";
|
|
var dataViewCtorString = toSource_default(DataView_default);
|
|
var mapCtorString = toSource_default(Map_default);
|
|
var promiseCtorString = toSource_default(Promise_default);
|
|
var setCtorString = toSource_default(Set_default);
|
|
var weakMapCtorString = toSource_default(WeakMap_default);
|
|
var getTag = baseGetTag_default;
|
|
if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
|
|
getTag = function(value) {
|
|
var result = baseGetTag_default(value), Ctor = result == objectTag3 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
|
|
if (ctorString) {
|
|
switch (ctorString) {
|
|
case dataViewCtorString:
|
|
return dataViewTag2;
|
|
case mapCtorString:
|
|
return mapTag2;
|
|
case promiseCtorString:
|
|
return promiseTag;
|
|
case setCtorString:
|
|
return setTag2;
|
|
case weakMapCtorString:
|
|
return weakMapTag2;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
var getTag_default = getTag;
|
|
|
|
// ../node_modules/lodash-es/_initCloneArray.js
|
|
var objectProto14 = Object.prototype;
|
|
var hasOwnProperty11 = objectProto14.hasOwnProperty;
|
|
function initCloneArray(array) {
|
|
var length = array.length, result = new array.constructor(length);
|
|
if (length && typeof array[0] == "string" && hasOwnProperty11.call(array, "index")) {
|
|
result.index = array.index;
|
|
result.input = array.input;
|
|
}
|
|
return result;
|
|
}
|
|
var initCloneArray_default = initCloneArray;
|
|
|
|
// ../node_modules/lodash-es/_Uint8Array.js
|
|
var Uint8Array2 = root_default.Uint8Array;
|
|
var Uint8Array_default = Uint8Array2;
|
|
|
|
// ../node_modules/lodash-es/_cloneArrayBuffer.js
|
|
function cloneArrayBuffer(arrayBuffer) {
|
|
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
|
|
new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer));
|
|
return result;
|
|
}
|
|
var cloneArrayBuffer_default = cloneArrayBuffer;
|
|
|
|
// ../node_modules/lodash-es/_cloneDataView.js
|
|
function cloneDataView(dataView, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
|
|
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
|
|
}
|
|
var cloneDataView_default = cloneDataView;
|
|
|
|
// ../node_modules/lodash-es/_cloneRegExp.js
|
|
var reFlags = /\w*$/;
|
|
function cloneRegExp(regexp) {
|
|
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
|
|
result.lastIndex = regexp.lastIndex;
|
|
return result;
|
|
}
|
|
var cloneRegExp_default = cloneRegExp;
|
|
|
|
// ../node_modules/lodash-es/_cloneSymbol.js
|
|
var symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
|
|
function cloneSymbol(symbol) {
|
|
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
|
|
}
|
|
var cloneSymbol_default = cloneSymbol;
|
|
|
|
// ../node_modules/lodash-es/_cloneTypedArray.js
|
|
function cloneTypedArray(typedArray, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
|
|
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
|
|
}
|
|
var cloneTypedArray_default = cloneTypedArray;
|
|
|
|
// ../node_modules/lodash-es/_initCloneByTag.js
|
|
var boolTag2 = "[object Boolean]";
|
|
var dateTag2 = "[object Date]";
|
|
var mapTag3 = "[object Map]";
|
|
var numberTag2 = "[object Number]";
|
|
var regexpTag2 = "[object RegExp]";
|
|
var setTag3 = "[object Set]";
|
|
var stringTag2 = "[object String]";
|
|
var symbolTag2 = "[object Symbol]";
|
|
var arrayBufferTag2 = "[object ArrayBuffer]";
|
|
var dataViewTag3 = "[object DataView]";
|
|
var float32Tag2 = "[object Float32Array]";
|
|
var float64Tag2 = "[object Float64Array]";
|
|
var int8Tag2 = "[object Int8Array]";
|
|
var int16Tag2 = "[object Int16Array]";
|
|
var int32Tag2 = "[object Int32Array]";
|
|
var uint8Tag2 = "[object Uint8Array]";
|
|
var uint8ClampedTag2 = "[object Uint8ClampedArray]";
|
|
var uint16Tag2 = "[object Uint16Array]";
|
|
var uint32Tag2 = "[object Uint32Array]";
|
|
function initCloneByTag(object, tag, isDeep) {
|
|
var Ctor = object.constructor;
|
|
switch (tag) {
|
|
case arrayBufferTag2:
|
|
return cloneArrayBuffer_default(object);
|
|
case boolTag2:
|
|
case dateTag2:
|
|
return new Ctor(+object);
|
|
case dataViewTag3:
|
|
return cloneDataView_default(object, isDeep);
|
|
case float32Tag2:
|
|
case float64Tag2:
|
|
case int8Tag2:
|
|
case int16Tag2:
|
|
case int32Tag2:
|
|
case uint8Tag2:
|
|
case uint8ClampedTag2:
|
|
case uint16Tag2:
|
|
case uint32Tag2:
|
|
return cloneTypedArray_default(object, isDeep);
|
|
case mapTag3:
|
|
return new Ctor();
|
|
case numberTag2:
|
|
case stringTag2:
|
|
return new Ctor(object);
|
|
case regexpTag2:
|
|
return cloneRegExp_default(object);
|
|
case setTag3:
|
|
return new Ctor();
|
|
case symbolTag2:
|
|
return cloneSymbol_default(object);
|
|
}
|
|
}
|
|
var initCloneByTag_default = initCloneByTag;
|
|
|
|
// ../node_modules/lodash-es/_initCloneObject.js
|
|
function initCloneObject(object) {
|
|
return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
|
|
}
|
|
var initCloneObject_default = initCloneObject;
|
|
|
|
// ../node_modules/lodash-es/_baseIsMap.js
|
|
var mapTag4 = "[object Map]";
|
|
function baseIsMap(value) {
|
|
return isObjectLike_default(value) && getTag_default(value) == mapTag4;
|
|
}
|
|
var baseIsMap_default = baseIsMap;
|
|
|
|
// ../node_modules/lodash-es/isMap.js
|
|
var nodeIsMap = nodeUtil_default && nodeUtil_default.isMap;
|
|
var isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default;
|
|
var isMap_default = isMap;
|
|
|
|
// ../node_modules/lodash-es/_baseIsSet.js
|
|
var setTag4 = "[object Set]";
|
|
function baseIsSet(value) {
|
|
return isObjectLike_default(value) && getTag_default(value) == setTag4;
|
|
}
|
|
var baseIsSet_default = baseIsSet;
|
|
|
|
// ../node_modules/lodash-es/isSet.js
|
|
var nodeIsSet = nodeUtil_default && nodeUtil_default.isSet;
|
|
var isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default;
|
|
var isSet_default = isSet;
|
|
|
|
// ../node_modules/lodash-es/_baseClone.js
|
|
var CLONE_DEEP_FLAG = 1;
|
|
var CLONE_FLAT_FLAG = 2;
|
|
var CLONE_SYMBOLS_FLAG = 4;
|
|
var argsTag3 = "[object Arguments]";
|
|
var arrayTag2 = "[object Array]";
|
|
var boolTag3 = "[object Boolean]";
|
|
var dateTag3 = "[object Date]";
|
|
var errorTag2 = "[object Error]";
|
|
var funcTag3 = "[object Function]";
|
|
var genTag2 = "[object GeneratorFunction]";
|
|
var mapTag5 = "[object Map]";
|
|
var numberTag3 = "[object Number]";
|
|
var objectTag4 = "[object Object]";
|
|
var regexpTag3 = "[object RegExp]";
|
|
var setTag5 = "[object Set]";
|
|
var stringTag3 = "[object String]";
|
|
var symbolTag3 = "[object Symbol]";
|
|
var weakMapTag3 = "[object WeakMap]";
|
|
var arrayBufferTag3 = "[object ArrayBuffer]";
|
|
var dataViewTag4 = "[object DataView]";
|
|
var float32Tag3 = "[object Float32Array]";
|
|
var float64Tag3 = "[object Float64Array]";
|
|
var int8Tag3 = "[object Int8Array]";
|
|
var int16Tag3 = "[object Int16Array]";
|
|
var int32Tag3 = "[object Int32Array]";
|
|
var uint8Tag3 = "[object Uint8Array]";
|
|
var uint8ClampedTag3 = "[object Uint8ClampedArray]";
|
|
var uint16Tag3 = "[object Uint16Array]";
|
|
var uint32Tag3 = "[object Uint32Array]";
|
|
var cloneableTags = {};
|
|
cloneableTags[argsTag3] = cloneableTags[arrayTag2] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag3] = cloneableTags[float64Tag3] = cloneableTags[int8Tag3] = cloneableTags[int16Tag3] = cloneableTags[int32Tag3] = cloneableTags[mapTag5] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag5] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag3] = cloneableTags[uint8ClampedTag3] = cloneableTags[uint16Tag3] = cloneableTags[uint32Tag3] = true;
|
|
cloneableTags[errorTag2] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false;
|
|
function baseClone(value, bitmask, customizer, key, object, stack) {
|
|
var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
|
|
if (customizer) {
|
|
result = object ? customizer(value, key, object, stack) : customizer(value);
|
|
}
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
if (!isObject_default(value)) {
|
|
return value;
|
|
}
|
|
var isArr = isArray_default(value);
|
|
if (isArr) {
|
|
result = initCloneArray_default(value);
|
|
if (!isDeep) {
|
|
return copyArray_default(value, result);
|
|
}
|
|
} else {
|
|
var tag = getTag_default(value), isFunc = tag == funcTag3 || tag == genTag2;
|
|
if (isBuffer_default(value)) {
|
|
return cloneBuffer_default(value, isDeep);
|
|
}
|
|
if (tag == objectTag4 || tag == argsTag3 || isFunc && !object) {
|
|
result = isFlat || isFunc ? {} : initCloneObject_default(value);
|
|
if (!isDeep) {
|
|
return isFlat ? copySymbolsIn_default(value, baseAssignIn_default(result, value)) : copySymbols_default(value, baseAssign_default(result, value));
|
|
}
|
|
} else {
|
|
if (!cloneableTags[tag]) {
|
|
return object ? value : {};
|
|
}
|
|
result = initCloneByTag_default(value, tag, isDeep);
|
|
}
|
|
}
|
|
stack || (stack = new Stack_default());
|
|
var stacked = stack.get(value);
|
|
if (stacked) {
|
|
return stacked;
|
|
}
|
|
stack.set(value, result);
|
|
if (isSet_default(value)) {
|
|
value.forEach(function(subValue) {
|
|
result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
|
|
});
|
|
} else if (isMap_default(value)) {
|
|
value.forEach(function(subValue, key2) {
|
|
result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
}
|
|
var keysFunc = isFull ? isFlat ? getAllKeysIn_default : getAllKeys_default : isFlat ? keysIn_default : keys_default;
|
|
var props = isArr ? void 0 : keysFunc(value);
|
|
arrayEach_default(props || value, function(subValue, key2) {
|
|
if (props) {
|
|
key2 = subValue;
|
|
subValue = value[key2];
|
|
}
|
|
assignValue_default(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
return result;
|
|
}
|
|
var baseClone_default = baseClone;
|
|
|
|
// ../node_modules/lodash-es/cloneDeep.js
|
|
var CLONE_DEEP_FLAG2 = 1;
|
|
var CLONE_SYMBOLS_FLAG2 = 4;
|
|
function cloneDeep(value) {
|
|
return baseClone_default(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG2);
|
|
}
|
|
var cloneDeep_default = cloneDeep;
|
|
|
|
// ../node_modules/lodash-es/_setCacheAdd.js
|
|
var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
|
|
function setCacheAdd(value) {
|
|
this.__data__.set(value, HASH_UNDEFINED3);
|
|
return this;
|
|
}
|
|
var setCacheAdd_default = setCacheAdd;
|
|
|
|
// ../node_modules/lodash-es/_setCacheHas.js
|
|
function setCacheHas(value) {
|
|
return this.__data__.has(value);
|
|
}
|
|
var setCacheHas_default = setCacheHas;
|
|
|
|
// ../node_modules/lodash-es/_SetCache.js
|
|
function SetCache(values) {
|
|
var index = -1, length = values == null ? 0 : values.length;
|
|
this.__data__ = new MapCache_default();
|
|
while (++index < length) {
|
|
this.add(values[index]);
|
|
}
|
|
}
|
|
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
|
|
SetCache.prototype.has = setCacheHas_default;
|
|
var SetCache_default = SetCache;
|
|
|
|
// ../node_modules/lodash-es/_arraySome.js
|
|
function arraySome(array, predicate) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (predicate(array[index], index, array)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var arraySome_default = arraySome;
|
|
|
|
// ../node_modules/lodash-es/_cacheHas.js
|
|
function cacheHas(cache2, key) {
|
|
return cache2.has(key);
|
|
}
|
|
var cacheHas_default = cacheHas;
|
|
|
|
// ../node_modules/lodash-es/_equalArrays.js
|
|
var COMPARE_PARTIAL_FLAG = 1;
|
|
var COMPARE_UNORDERED_FLAG = 2;
|
|
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
|
|
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
|
|
return false;
|
|
}
|
|
var arrStacked = stack.get(array);
|
|
var othStacked = stack.get(other);
|
|
if (arrStacked && othStacked) {
|
|
return arrStacked == other && othStacked == array;
|
|
}
|
|
var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
|
|
stack.set(array, other);
|
|
stack.set(other, array);
|
|
while (++index < arrLength) {
|
|
var arrValue = array[index], othValue = other[index];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
|
|
}
|
|
if (compared !== void 0) {
|
|
if (compared) {
|
|
continue;
|
|
}
|
|
result = false;
|
|
break;
|
|
}
|
|
if (seen) {
|
|
if (!arraySome_default(other, function(othValue2, othIndex) {
|
|
if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
|
|
return seen.push(othIndex);
|
|
}
|
|
})) {
|
|
result = false;
|
|
break;
|
|
}
|
|
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
|
|
result = false;
|
|
break;
|
|
}
|
|
}
|
|
stack["delete"](array);
|
|
stack["delete"](other);
|
|
return result;
|
|
}
|
|
var equalArrays_default = equalArrays;
|
|
|
|
// ../node_modules/lodash-es/_mapToArray.js
|
|
function mapToArray(map) {
|
|
var index = -1, result = Array(map.size);
|
|
map.forEach(function(value, key) {
|
|
result[++index] = [key, value];
|
|
});
|
|
return result;
|
|
}
|
|
var mapToArray_default = mapToArray;
|
|
|
|
// ../node_modules/lodash-es/_setToArray.js
|
|
function setToArray(set2) {
|
|
var index = -1, result = Array(set2.size);
|
|
set2.forEach(function(value) {
|
|
result[++index] = value;
|
|
});
|
|
return result;
|
|
}
|
|
var setToArray_default = setToArray;
|
|
|
|
// ../node_modules/lodash-es/_equalByTag.js
|
|
var COMPARE_PARTIAL_FLAG2 = 1;
|
|
var COMPARE_UNORDERED_FLAG2 = 2;
|
|
var boolTag4 = "[object Boolean]";
|
|
var dateTag4 = "[object Date]";
|
|
var errorTag3 = "[object Error]";
|
|
var mapTag6 = "[object Map]";
|
|
var numberTag4 = "[object Number]";
|
|
var regexpTag4 = "[object RegExp]";
|
|
var setTag6 = "[object Set]";
|
|
var stringTag4 = "[object String]";
|
|
var symbolTag4 = "[object Symbol]";
|
|
var arrayBufferTag4 = "[object ArrayBuffer]";
|
|
var dataViewTag5 = "[object DataView]";
|
|
var symbolProto3 = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0;
|
|
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
|
|
switch (tag) {
|
|
case dataViewTag5:
|
|
if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
|
|
return false;
|
|
}
|
|
object = object.buffer;
|
|
other = other.buffer;
|
|
case arrayBufferTag4:
|
|
if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object), new Uint8Array_default(other))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case boolTag4:
|
|
case dateTag4:
|
|
case numberTag4:
|
|
return eq_default(+object, +other);
|
|
case errorTag3:
|
|
return object.name == other.name && object.message == other.message;
|
|
case regexpTag4:
|
|
case stringTag4:
|
|
return object == other + "";
|
|
case mapTag6:
|
|
var convert = mapToArray_default;
|
|
case setTag6:
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
|
|
convert || (convert = setToArray_default);
|
|
if (object.size != other.size && !isPartial) {
|
|
return false;
|
|
}
|
|
var stacked = stack.get(object);
|
|
if (stacked) {
|
|
return stacked == other;
|
|
}
|
|
bitmask |= COMPARE_UNORDERED_FLAG2;
|
|
stack.set(object, other);
|
|
var result = equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
|
|
stack["delete"](object);
|
|
return result;
|
|
case symbolTag4:
|
|
if (symbolValueOf2) {
|
|
return symbolValueOf2.call(object) == symbolValueOf2.call(other);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var equalByTag_default = equalByTag;
|
|
|
|
// ../node_modules/lodash-es/_equalObjects.js
|
|
var COMPARE_PARTIAL_FLAG3 = 1;
|
|
var objectProto15 = Object.prototype;
|
|
var hasOwnProperty12 = objectProto15.hasOwnProperty;
|
|
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length;
|
|
if (objLength != othLength && !isPartial) {
|
|
return false;
|
|
}
|
|
var index = objLength;
|
|
while (index--) {
|
|
var key = objProps[index];
|
|
if (!(isPartial ? key in other : hasOwnProperty12.call(other, key))) {
|
|
return false;
|
|
}
|
|
}
|
|
var objStacked = stack.get(object);
|
|
var othStacked = stack.get(other);
|
|
if (objStacked && othStacked) {
|
|
return objStacked == other && othStacked == object;
|
|
}
|
|
var result = true;
|
|
stack.set(object, other);
|
|
stack.set(other, object);
|
|
var skipCtor = isPartial;
|
|
while (++index < objLength) {
|
|
key = objProps[index];
|
|
var objValue = object[key], othValue = other[key];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
|
|
}
|
|
if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
|
|
result = false;
|
|
break;
|
|
}
|
|
skipCtor || (skipCtor = key == "constructor");
|
|
}
|
|
if (result && !skipCtor) {
|
|
var objCtor = object.constructor, othCtor = other.constructor;
|
|
if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
|
|
result = false;
|
|
}
|
|
}
|
|
stack["delete"](object);
|
|
stack["delete"](other);
|
|
return result;
|
|
}
|
|
var equalObjects_default = equalObjects;
|
|
|
|
// ../node_modules/lodash-es/_baseIsEqualDeep.js
|
|
var COMPARE_PARTIAL_FLAG4 = 1;
|
|
var argsTag4 = "[object Arguments]";
|
|
var arrayTag3 = "[object Array]";
|
|
var objectTag5 = "[object Object]";
|
|
var objectProto16 = Object.prototype;
|
|
var hasOwnProperty13 = objectProto16.hasOwnProperty;
|
|
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
|
|
var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag3 : getTag_default(object), othTag = othIsArr ? arrayTag3 : getTag_default(other);
|
|
objTag = objTag == argsTag4 ? objectTag5 : objTag;
|
|
othTag = othTag == argsTag4 ? objectTag5 : othTag;
|
|
var objIsObj = objTag == objectTag5, othIsObj = othTag == objectTag5, isSameTag = objTag == othTag;
|
|
if (isSameTag && isBuffer_default(object)) {
|
|
if (!isBuffer_default(other)) {
|
|
return false;
|
|
}
|
|
objIsArr = true;
|
|
objIsObj = false;
|
|
}
|
|
if (isSameTag && !objIsObj) {
|
|
stack || (stack = new Stack_default());
|
|
return objIsArr || isTypedArray_default(object) ? equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
|
|
var objIsWrapped = objIsObj && hasOwnProperty13.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty13.call(other, "__wrapped__");
|
|
if (objIsWrapped || othIsWrapped) {
|
|
var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
|
|
stack || (stack = new Stack_default());
|
|
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
|
|
}
|
|
}
|
|
if (!isSameTag) {
|
|
return false;
|
|
}
|
|
stack || (stack = new Stack_default());
|
|
return equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
var baseIsEqualDeep_default = baseIsEqualDeep;
|
|
|
|
// ../node_modules/lodash-es/_baseIsEqual.js
|
|
function baseIsEqual(value, other, bitmask, customizer, stack) {
|
|
if (value === other) {
|
|
return true;
|
|
}
|
|
if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
|
|
return value !== value && other !== other;
|
|
}
|
|
return baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
|
|
}
|
|
var baseIsEqual_default = baseIsEqual;
|
|
|
|
// ../node_modules/lodash-es/_baseIsMatch.js
|
|
var COMPARE_PARTIAL_FLAG5 = 1;
|
|
var COMPARE_UNORDERED_FLAG3 = 2;
|
|
function baseIsMatch(object, source, matchData, customizer) {
|
|
var index = matchData.length, length = index, noCustomizer = !customizer;
|
|
if (object == null) {
|
|
return !length;
|
|
}
|
|
object = Object(object);
|
|
while (index--) {
|
|
var data = matchData[index];
|
|
if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
|
|
return false;
|
|
}
|
|
}
|
|
while (++index < length) {
|
|
data = matchData[index];
|
|
var key = data[0], objValue = object[key], srcValue = data[1];
|
|
if (noCustomizer && data[2]) {
|
|
if (objValue === void 0 && !(key in object)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
var stack = new Stack_default();
|
|
if (customizer) {
|
|
var result = customizer(objValue, srcValue, key, object, source, stack);
|
|
}
|
|
if (!(result === void 0 ? baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var baseIsMatch_default = baseIsMatch;
|
|
|
|
// ../node_modules/lodash-es/_isStrictComparable.js
|
|
function isStrictComparable(value) {
|
|
return value === value && !isObject_default(value);
|
|
}
|
|
var isStrictComparable_default = isStrictComparable;
|
|
|
|
// ../node_modules/lodash-es/_getMatchData.js
|
|
function getMatchData(object) {
|
|
var result = keys_default(object), length = result.length;
|
|
while (length--) {
|
|
var key = result[length], value = object[key];
|
|
result[length] = [key, value, isStrictComparable_default(value)];
|
|
}
|
|
return result;
|
|
}
|
|
var getMatchData_default = getMatchData;
|
|
|
|
// ../node_modules/lodash-es/_matchesStrictComparable.js
|
|
function matchesStrictComparable(key, srcValue) {
|
|
return function(object) {
|
|
if (object == null) {
|
|
return false;
|
|
}
|
|
return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
|
|
};
|
|
}
|
|
var matchesStrictComparable_default = matchesStrictComparable;
|
|
|
|
// ../node_modules/lodash-es/_baseMatches.js
|
|
function baseMatches(source) {
|
|
var matchData = getMatchData_default(source);
|
|
if (matchData.length == 1 && matchData[0][2]) {
|
|
return matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
|
|
}
|
|
return function(object) {
|
|
return object === source || baseIsMatch_default(object, source, matchData);
|
|
};
|
|
}
|
|
var baseMatches_default = baseMatches;
|
|
|
|
// ../node_modules/lodash-es/_baseHasIn.js
|
|
function baseHasIn(object, key) {
|
|
return object != null && key in Object(object);
|
|
}
|
|
var baseHasIn_default = baseHasIn;
|
|
|
|
// ../node_modules/lodash-es/_hasPath.js
|
|
function hasPath(object, path, hasFunc) {
|
|
path = castPath_default(path, object);
|
|
var index = -1, length = path.length, result = false;
|
|
while (++index < length) {
|
|
var key = toKey_default(path[index]);
|
|
if (!(result = object != null && hasFunc(object, key))) {
|
|
break;
|
|
}
|
|
object = object[key];
|
|
}
|
|
if (result || ++index != length) {
|
|
return result;
|
|
}
|
|
length = object == null ? 0 : object.length;
|
|
return !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
|
|
}
|
|
var hasPath_default = hasPath;
|
|
|
|
// ../node_modules/lodash-es/hasIn.js
|
|
function hasIn(object, path) {
|
|
return object != null && hasPath_default(object, path, baseHasIn_default);
|
|
}
|
|
var hasIn_default = hasIn;
|
|
|
|
// ../node_modules/lodash-es/_baseMatchesProperty.js
|
|
var COMPARE_PARTIAL_FLAG6 = 1;
|
|
var COMPARE_UNORDERED_FLAG4 = 2;
|
|
function baseMatchesProperty(path, srcValue) {
|
|
if (isKey_default(path) && isStrictComparable_default(srcValue)) {
|
|
return matchesStrictComparable_default(toKey_default(path), srcValue);
|
|
}
|
|
return function(object) {
|
|
var objValue = get_default(object, path);
|
|
return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
|
|
};
|
|
}
|
|
var baseMatchesProperty_default = baseMatchesProperty;
|
|
|
|
// ../node_modules/lodash-es/_baseProperty.js
|
|
function baseProperty(key) {
|
|
return function(object) {
|
|
return object == null ? void 0 : object[key];
|
|
};
|
|
}
|
|
var baseProperty_default = baseProperty;
|
|
|
|
// ../node_modules/lodash-es/_basePropertyDeep.js
|
|
function basePropertyDeep(path) {
|
|
return function(object) {
|
|
return baseGet_default(object, path);
|
|
};
|
|
}
|
|
var basePropertyDeep_default = basePropertyDeep;
|
|
|
|
// ../node_modules/lodash-es/property.js
|
|
function property(path) {
|
|
return isKey_default(path) ? baseProperty_default(toKey_default(path)) : basePropertyDeep_default(path);
|
|
}
|
|
var property_default = property;
|
|
|
|
// ../node_modules/lodash-es/_baseIteratee.js
|
|
function baseIteratee(value) {
|
|
if (typeof value == "function") {
|
|
return value;
|
|
}
|
|
if (value == null) {
|
|
return identity_default;
|
|
}
|
|
if (typeof value == "object") {
|
|
return isArray_default(value) ? baseMatchesProperty_default(value[0], value[1]) : baseMatches_default(value);
|
|
}
|
|
return property_default(value);
|
|
}
|
|
var baseIteratee_default = baseIteratee;
|
|
|
|
// ../node_modules/lodash-es/_createBaseFor.js
|
|
function createBaseFor(fromRight) {
|
|
return function(object, iteratee, keysFunc) {
|
|
var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
|
|
while (length--) {
|
|
var key = props[fromRight ? length : ++index];
|
|
if (iteratee(iterable[key], key, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
}
|
|
var createBaseFor_default = createBaseFor;
|
|
|
|
// ../node_modules/lodash-es/_baseFor.js
|
|
var baseFor = createBaseFor_default();
|
|
var baseFor_default = baseFor;
|
|
|
|
// ../node_modules/lodash-es/_baseForOwn.js
|
|
function baseForOwn(object, iteratee) {
|
|
return object && baseFor_default(object, iteratee, keys_default);
|
|
}
|
|
var baseForOwn_default = baseForOwn;
|
|
|
|
// ../node_modules/lodash-es/now.js
|
|
var now = function() {
|
|
return root_default.Date.now();
|
|
};
|
|
var now_default = now;
|
|
|
|
// ../node_modules/lodash-es/debounce.js
|
|
var FUNC_ERROR_TEXT2 = "Expected a function";
|
|
var nativeMax = Math.max;
|
|
var nativeMin = Math.min;
|
|
function debounce(func, wait, options) {
|
|
var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT2);
|
|
}
|
|
wait = toNumber_default(wait) || 0;
|
|
if (isObject_default(options)) {
|
|
leading = !!options.leading;
|
|
maxing = "maxWait" in options;
|
|
maxWait = maxing ? nativeMax(toNumber_default(options.maxWait) || 0, wait) : maxWait;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
function invokeFunc(time) {
|
|
var args = lastArgs, thisArg = lastThis;
|
|
lastArgs = lastThis = void 0;
|
|
lastInvokeTime = time;
|
|
result = func.apply(thisArg, args);
|
|
return result;
|
|
}
|
|
function leadingEdge(time) {
|
|
lastInvokeTime = time;
|
|
timerId = setTimeout(timerExpired, wait);
|
|
return leading ? invokeFunc(time) : result;
|
|
}
|
|
function remainingWait(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
|
|
return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
|
|
}
|
|
function shouldInvoke(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
|
|
return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
|
|
}
|
|
function timerExpired() {
|
|
var time = now_default();
|
|
if (shouldInvoke(time)) {
|
|
return trailingEdge(time);
|
|
}
|
|
timerId = setTimeout(timerExpired, remainingWait(time));
|
|
}
|
|
function trailingEdge(time) {
|
|
timerId = void 0;
|
|
if (trailing && lastArgs) {
|
|
return invokeFunc(time);
|
|
}
|
|
lastArgs = lastThis = void 0;
|
|
return result;
|
|
}
|
|
function cancel() {
|
|
if (timerId !== void 0) {
|
|
clearTimeout(timerId);
|
|
}
|
|
lastInvokeTime = 0;
|
|
lastArgs = lastCallTime = lastThis = timerId = void 0;
|
|
}
|
|
function flush() {
|
|
return timerId === void 0 ? result : trailingEdge(now_default());
|
|
}
|
|
function debounced() {
|
|
var time = now_default(), isInvoking = shouldInvoke(time);
|
|
lastArgs = arguments;
|
|
lastThis = this;
|
|
lastCallTime = time;
|
|
if (isInvoking) {
|
|
if (timerId === void 0) {
|
|
return leadingEdge(lastCallTime);
|
|
}
|
|
if (maxing) {
|
|
clearTimeout(timerId);
|
|
timerId = setTimeout(timerExpired, wait);
|
|
return invokeFunc(lastCallTime);
|
|
}
|
|
}
|
|
if (timerId === void 0) {
|
|
timerId = setTimeout(timerExpired, wait);
|
|
}
|
|
return result;
|
|
}
|
|
debounced.cancel = cancel;
|
|
debounced.flush = flush;
|
|
return debounced;
|
|
}
|
|
var debounce_default = debounce;
|
|
|
|
// ../node_modules/lodash-es/last.js
|
|
function last(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? array[length - 1] : void 0;
|
|
}
|
|
var last_default = last;
|
|
|
|
// ../node_modules/lodash-es/_parent.js
|
|
function parent(object, path) {
|
|
return path.length < 2 ? object : baseGet_default(object, baseSlice_default(path, 0, -1));
|
|
}
|
|
var parent_default = parent;
|
|
|
|
// ../node_modules/lodash-es/isInteger.js
|
|
function isInteger(value) {
|
|
return typeof value == "number" && value == toInteger_default(value);
|
|
}
|
|
var isInteger_default = isInteger;
|
|
|
|
// ../node_modules/lodash-es/mapValues.js
|
|
function mapValues(object, iteratee) {
|
|
var result = {};
|
|
iteratee = baseIteratee_default(iteratee, 3);
|
|
baseForOwn_default(object, function(value, key, object2) {
|
|
baseAssignValue_default(result, key, iteratee(value, key, object2));
|
|
});
|
|
return result;
|
|
}
|
|
var mapValues_default = mapValues;
|
|
|
|
// ../node_modules/lodash-es/_baseUnset.js
|
|
function baseUnset(object, path) {
|
|
path = castPath_default(path, object);
|
|
object = parent_default(object, path);
|
|
return object == null || delete object[toKey_default(last_default(path))];
|
|
}
|
|
var baseUnset_default = baseUnset;
|
|
|
|
// ../node_modules/lodash-es/_baseRepeat.js
|
|
var MAX_SAFE_INTEGER3 = 9007199254740991;
|
|
var nativeFloor = Math.floor;
|
|
function baseRepeat(string2, n2) {
|
|
var result = "";
|
|
if (!string2 || n2 < 1 || n2 > MAX_SAFE_INTEGER3) {
|
|
return result;
|
|
}
|
|
do {
|
|
if (n2 % 2) {
|
|
result += string2;
|
|
}
|
|
n2 = nativeFloor(n2 / 2);
|
|
if (n2) {
|
|
string2 += string2;
|
|
}
|
|
} while (n2);
|
|
return result;
|
|
}
|
|
var baseRepeat_default = baseRepeat;
|
|
|
|
// ../node_modules/lodash-es/_asciiSize.js
|
|
var asciiSize = baseProperty_default("length");
|
|
var asciiSize_default = asciiSize;
|
|
|
|
// ../node_modules/lodash-es/_unicodeSize.js
|
|
var rsAstralRange3 = "\\ud800-\\udfff";
|
|
var rsComboMarksRange3 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange3 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange3 = "\\u20d0-\\u20ff";
|
|
var rsComboRange3 = rsComboMarksRange3 + reComboHalfMarksRange3 + rsComboSymbolsRange3;
|
|
var rsVarRange3 = "\\ufe0e\\ufe0f";
|
|
var rsAstral2 = "[" + rsAstralRange3 + "]";
|
|
var rsCombo2 = "[" + rsComboRange3 + "]";
|
|
var rsFitz2 = "\\ud83c[\\udffb-\\udfff]";
|
|
var rsModifier2 = "(?:" + rsCombo2 + "|" + rsFitz2 + ")";
|
|
var rsNonAstral2 = "[^" + rsAstralRange3 + "]";
|
|
var rsRegional2 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
var rsSurrPair2 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
var rsZWJ3 = "\\u200d";
|
|
var reOptMod2 = rsModifier2 + "?";
|
|
var rsOptVar2 = "[" + rsVarRange3 + "]?";
|
|
var rsOptJoin2 = "(?:" + rsZWJ3 + "(?:" + [rsNonAstral2, rsRegional2, rsSurrPair2].join("|") + ")" + rsOptVar2 + reOptMod2 + ")*";
|
|
var rsSeq2 = rsOptVar2 + reOptMod2 + rsOptJoin2;
|
|
var rsSymbol2 = "(?:" + [rsNonAstral2 + rsCombo2 + "?", rsCombo2, rsRegional2, rsSurrPair2, rsAstral2].join("|") + ")";
|
|
var reUnicode2 = RegExp(rsFitz2 + "(?=" + rsFitz2 + ")|" + rsSymbol2 + rsSeq2, "g");
|
|
function unicodeSize(string2) {
|
|
var result = reUnicode2.lastIndex = 0;
|
|
while (reUnicode2.test(string2)) {
|
|
++result;
|
|
}
|
|
return result;
|
|
}
|
|
var unicodeSize_default = unicodeSize;
|
|
|
|
// ../node_modules/lodash-es/_stringSize.js
|
|
function stringSize(string2) {
|
|
return hasUnicode_default(string2) ? unicodeSize_default(string2) : asciiSize_default(string2);
|
|
}
|
|
var stringSize_default = stringSize;
|
|
|
|
// ../node_modules/lodash-es/_createPadding.js
|
|
var nativeCeil = Math.ceil;
|
|
function createPadding(length, chars) {
|
|
chars = chars === void 0 ? " " : baseToString_default(chars);
|
|
var charsLength = chars.length;
|
|
if (charsLength < 2) {
|
|
return charsLength ? baseRepeat_default(chars, length) : chars;
|
|
}
|
|
var result = baseRepeat_default(chars, nativeCeil(length / stringSize_default(chars)));
|
|
return hasUnicode_default(chars) ? castSlice_default(stringToArray_default(result), 0, length).join("") : result.slice(0, length);
|
|
}
|
|
var createPadding_default = createPadding;
|
|
|
|
// ../node_modules/lodash-es/padStart.js
|
|
function padStart(string2, length, chars) {
|
|
string2 = toString_default(string2);
|
|
length = toInteger_default(length);
|
|
var strLength = length ? stringSize_default(string2) : 0;
|
|
return length && strLength < length ? createPadding_default(length - strLength, chars) + string2 : string2;
|
|
}
|
|
var padStart_default = padStart;
|
|
|
|
// ../node_modules/lodash-es/unset.js
|
|
function unset(object, path) {
|
|
return object == null ? true : baseUnset_default(object, path);
|
|
}
|
|
var unset_default = unset;
|
|
|
|
// core/src/sheetObjects/TheatreSheetObject.ts
|
|
var KEEP_HOT_FOR_MS = 5 * 1e3;
|
|
var TheatreSheetObject = class {
|
|
/**
|
|
* @internal
|
|
*/
|
|
constructor(internals) {
|
|
__publicField(this, "_cache", new SimpleCache());
|
|
/** @internal See https://linear.app/theatre/issue/P-217/if-objvalue-is-read-make-sure-its-derivation-remains-hot-for-a-while */
|
|
__publicField(this, "_keepHotUntapDebounce");
|
|
setPrivateAPI(this, internals);
|
|
}
|
|
get type() {
|
|
return "Theatre_SheetObject_PublicAPI";
|
|
}
|
|
get props() {
|
|
return privateAPI(this).propsP;
|
|
}
|
|
get sheet() {
|
|
return privateAPI(this).sheet.publicApi;
|
|
}
|
|
get project() {
|
|
return privateAPI(this).sheet.project.publicApi;
|
|
}
|
|
get address() {
|
|
return __spreadValues({}, privateAPI(this).address);
|
|
}
|
|
_valuesPrism() {
|
|
return this._cache.get("_valuesPrism", () => {
|
|
const sheetObject = privateAPI(this);
|
|
const d2 = (0, import_dataverse4.prism)(() => {
|
|
return (0, import_dataverse4.val)(sheetObject.getValues().getValue());
|
|
});
|
|
return d2;
|
|
});
|
|
}
|
|
onValuesChange(fn2, rafDriver) {
|
|
return onChange(this._valuesPrism(), fn2, rafDriver);
|
|
}
|
|
// internal: Make the deviration keepHot if directly read
|
|
get value() {
|
|
const der = this._valuesPrism();
|
|
if (KEEP_HOT_FOR_MS != null) {
|
|
if (!der.isHot) {
|
|
if (this._keepHotUntapDebounce != null) {
|
|
if (process.env.NODE_ENV === "development") {
|
|
privateAPI(this)._logger.errorDev(
|
|
"`sheet.value` keepHot debouncer is set, even though the derivation is not actually hot."
|
|
);
|
|
}
|
|
this._keepHotUntapDebounce.flush();
|
|
}
|
|
const untap = der.keepHot();
|
|
this._keepHotUntapDebounce = debounce_default(() => {
|
|
untap();
|
|
this._keepHotUntapDebounce = void 0;
|
|
}, KEEP_HOT_FOR_MS);
|
|
}
|
|
if (this._keepHotUntapDebounce) {
|
|
this._keepHotUntapDebounce();
|
|
}
|
|
}
|
|
return der.getValue();
|
|
}
|
|
set initialValue(val8) {
|
|
privateAPI(this).setInitialValue(val8);
|
|
}
|
|
};
|
|
|
|
// shared/src/utils/memoizeFn.ts
|
|
function memoizeFn(producer) {
|
|
const cache2 = /* @__PURE__ */ new WeakMap();
|
|
return (k2) => {
|
|
if (!cache2.has(k2)) {
|
|
cache2.set(k2, producer(k2));
|
|
}
|
|
return cache2.get(k2);
|
|
};
|
|
}
|
|
|
|
// shared/src/propTypes/utils.ts
|
|
function isPropConfigComposite(c2) {
|
|
return c2.type === "compound" || c2.type === "enum";
|
|
}
|
|
function getPropConfigByPath(parentConf, path) {
|
|
if (!parentConf)
|
|
return void 0;
|
|
const [key, ...rest] = path;
|
|
if (key === void 0)
|
|
return parentConf;
|
|
if (!isPropConfigComposite(parentConf))
|
|
return void 0;
|
|
const sub = parentConf.type === "enum" ? parentConf.cases[key] : parentConf.props[key];
|
|
return getPropConfigByPath(sub, rest);
|
|
}
|
|
function isPropConfSequencable(conf) {
|
|
return !isPropConfigComposite(conf);
|
|
}
|
|
var compoundHasSimpleDescendants = memoizeFn(
|
|
(conf) => {
|
|
if (conf.type === "enum") {
|
|
throw new Error("Not implemented yet for enums");
|
|
}
|
|
for (const key in conf.props) {
|
|
const subConf = conf.props[key];
|
|
if (isPropConfigComposite(subConf)) {
|
|
if (compoundHasSimpleDescendants(subConf)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
);
|
|
|
|
// core/src/sheetObjects/SheetObject.ts
|
|
var SheetObject = class {
|
|
constructor(sheet, template, nativeObject) {
|
|
this.sheet = sheet;
|
|
this.template = template;
|
|
this.nativeObject = nativeObject;
|
|
__publicField(this, "$$isPointerToPrismProvider", true);
|
|
__publicField(this, "address");
|
|
__publicField(this, "publicApi");
|
|
__publicField(this, "_initialValue", new import_dataverse5.Atom({}));
|
|
__publicField(this, "_cache", new SimpleCache());
|
|
__publicField(this, "_logger");
|
|
__publicField(this, "_internalUtilCtx");
|
|
this._logger = sheet._logger.named(
|
|
"SheetObject",
|
|
template.address.objectKey
|
|
);
|
|
this._logger._trace("creating object");
|
|
this._internalUtilCtx = { logger: this._logger.utilFor.internal() };
|
|
this.address = __spreadProps(__spreadValues({}, template.address), {
|
|
sheetInstanceId: sheet.address.sheetInstanceId
|
|
});
|
|
this.publicApi = new TheatreSheetObject(this);
|
|
}
|
|
get type() {
|
|
return "Theatre_SheetObject";
|
|
}
|
|
getValues() {
|
|
return this._cache.get(
|
|
"getValues()",
|
|
() => (0, import_dataverse5.prism)(() => {
|
|
const defaults = (0, import_dataverse5.val)(this.template.getDefaultValues());
|
|
const initial = (0, import_dataverse5.val)(this._initialValue.pointer);
|
|
const withInitialCache = import_dataverse5.prism.memo(
|
|
"withInitialCache",
|
|
() => /* @__PURE__ */ new WeakMap(),
|
|
[]
|
|
);
|
|
const withInitial = deepMergeWithCache(
|
|
defaults,
|
|
initial,
|
|
withInitialCache
|
|
);
|
|
const statics = (0, import_dataverse5.val)(this.template.getStaticValues());
|
|
const withStaticsCache = import_dataverse5.prism.memo(
|
|
"withStatics",
|
|
() => /* @__PURE__ */ new WeakMap(),
|
|
[]
|
|
);
|
|
const withStatics = deepMergeWithCache(
|
|
withInitial,
|
|
statics,
|
|
withStaticsCache
|
|
);
|
|
let final = withStatics;
|
|
let sequenced;
|
|
{
|
|
const pointerToSequencedValuesD = import_dataverse5.prism.memo(
|
|
"seq",
|
|
() => this.getSequencedValues(),
|
|
[]
|
|
);
|
|
const withSeqsCache = import_dataverse5.prism.memo(
|
|
"withSeqsCache",
|
|
() => /* @__PURE__ */ new WeakMap(),
|
|
[]
|
|
);
|
|
sequenced = (0, import_dataverse5.val)((0, import_dataverse5.val)(pointerToSequencedValuesD));
|
|
const withSeqs = deepMergeWithCache(final, sequenced, withSeqsCache);
|
|
final = withSeqs;
|
|
}
|
|
const a2 = valToAtom("finalAtom", final);
|
|
return a2.pointer;
|
|
})
|
|
);
|
|
}
|
|
getValueByPointer(pointer3) {
|
|
const allValuesP = (0, import_dataverse5.val)(this.getValues());
|
|
const { path } = (0, import_dataverse5.getPointerParts)(pointer3);
|
|
return (0, import_dataverse5.val)(
|
|
pointerDeep(allValuesP, path)
|
|
);
|
|
}
|
|
pointerToPrism(pointer3) {
|
|
const { path } = (0, import_dataverse5.getPointerParts)(pointer3);
|
|
return (0, import_dataverse5.prism)(() => {
|
|
const allValuesP = (0, import_dataverse5.val)(this.getValues());
|
|
return (0, import_dataverse5.val)(pointerDeep(allValuesP, path));
|
|
});
|
|
}
|
|
/**
|
|
* Returns values of props that are sequenced.
|
|
*/
|
|
getSequencedValues() {
|
|
return (0, import_dataverse5.prism)(() => {
|
|
const tracksToProcessD = import_dataverse5.prism.memo(
|
|
"tracksToProcess",
|
|
() => this.template.getArrayOfValidSequenceTracks(),
|
|
[]
|
|
);
|
|
const tracksToProcess = (0, import_dataverse5.val)(tracksToProcessD);
|
|
const valsAtom = new import_dataverse5.Atom({});
|
|
const config = (0, import_dataverse5.val)(this.template.configPointer);
|
|
import_dataverse5.prism.effect(
|
|
"processTracks",
|
|
() => {
|
|
const untaps = [];
|
|
for (const { trackId, pathToProp } of tracksToProcess) {
|
|
const pr = this._trackIdToPrism(trackId);
|
|
const propConfig = getPropConfigByPath(
|
|
config,
|
|
pathToProp
|
|
);
|
|
const deserializeAndSanitize = propConfig.deserializeAndSanitize;
|
|
const interpolate = propConfig.interpolate;
|
|
const updateSequenceValueFromItsPrism = () => {
|
|
const triple = pr.getValue();
|
|
if (!triple)
|
|
return valsAtom.setByPointer(
|
|
(p2) => pointerDeep(p2, pathToProp),
|
|
void 0
|
|
);
|
|
const leftDeserialized = deserializeAndSanitize(triple.left);
|
|
const left = leftDeserialized === void 0 ? propConfig.default : leftDeserialized;
|
|
if (triple.right === void 0)
|
|
return valsAtom.setByPointer(
|
|
(p2) => pointerDeep(p2, pathToProp),
|
|
left
|
|
);
|
|
const rightDeserialized = deserializeAndSanitize(triple.right);
|
|
const right = rightDeserialized === void 0 ? propConfig.default : rightDeserialized;
|
|
return valsAtom.setByPointer(
|
|
(p2) => pointerDeep(p2, pathToProp),
|
|
interpolate(left, right, triple.progression)
|
|
);
|
|
};
|
|
const untap = pr.onStale(updateSequenceValueFromItsPrism);
|
|
updateSequenceValueFromItsPrism();
|
|
untaps.push(untap);
|
|
}
|
|
return () => {
|
|
for (const untap of untaps) {
|
|
untap();
|
|
}
|
|
};
|
|
},
|
|
[config, ...tracksToProcess]
|
|
);
|
|
return valsAtom.pointer;
|
|
});
|
|
}
|
|
_trackIdToPrism(trackId) {
|
|
const trackP = this.template.project.pointers.historic.sheetsById[this.address.sheetId].sequence.tracksByObject[this.address.objectKey].trackData[trackId];
|
|
const timeD = this.sheet.getSequence().positionPrism;
|
|
return interpolationTripleAtPosition(this._internalUtilCtx, trackP, timeD);
|
|
}
|
|
get propsP() {
|
|
return this._cache.get(
|
|
"propsP",
|
|
() => (0, import_dataverse5.pointer)({ root: this, path: [] })
|
|
);
|
|
}
|
|
validateValue(pointer3, value) {
|
|
}
|
|
setInitialValue(val8) {
|
|
this.validateValue(this.propsP, val8);
|
|
this._initialValue.set(val8);
|
|
}
|
|
};
|
|
|
|
// shared/src/_logger/logger.ts
|
|
function lazy(f2) {
|
|
return function lazyLogIncluded(m, lazyArg) {
|
|
return f2(m, lazyArg());
|
|
};
|
|
}
|
|
var LEVELS = {
|
|
_hmm: getLogMeta(524 /* _HMM */),
|
|
_todo: getLogMeta(522 /* _TODO */),
|
|
_error: getLogMeta(521 /* _ERROR */),
|
|
errorDev: getLogMeta(529 /* ERROR_DEV */),
|
|
errorPublic: getLogMeta(545 /* ERROR_PUBLIC */),
|
|
_kapow: getLogMeta(268 /* _KAPOW */),
|
|
_warn: getLogMeta(265 /* _WARN */),
|
|
warnDev: getLogMeta(273 /* WARN_DEV */),
|
|
warnPublic: getLogMeta(289 /* WARN_PUBLIC */),
|
|
_debug: getLogMeta(137 /* _DEBUG */),
|
|
debugDev: getLogMeta(145 /* DEBUG_DEV */),
|
|
_trace: getLogMeta(73 /* _TRACE */),
|
|
traceDev: getLogMeta(81 /* TRACE_DEV */)
|
|
};
|
|
function getLogMeta(level) {
|
|
return Object.freeze({
|
|
audience: hasFlag(level, 8 /* INTERNAL */) ? "internal" : hasFlag(level, 16 /* DEV */) ? "dev" : "public",
|
|
category: hasFlag(level, 4 /* TROUBLESHOOTING */) ? "troubleshooting" : hasFlag(level, 2 /* TODO */) ? "todo" : "general",
|
|
level: (
|
|
// I think this is equivalent... but I'm not using it until we have tests.
|
|
// this code won't really impact performance much anyway, since it's just computed once
|
|
// up front.
|
|
// level &
|
|
// (TheatreLoggerLevel.TRACE |
|
|
// TheatreLoggerLevel.DEBUG |
|
|
// TheatreLoggerLevel.WARN |
|
|
// TheatreLoggerLevel.ERROR),
|
|
hasFlag(level, 512 /* ERROR */) ? 512 /* ERROR */ : hasFlag(level, 256 /* WARN */) ? 256 /* WARN */ : hasFlag(level, 128 /* DEBUG */) ? 128 /* DEBUG */ : (
|
|
// no other option
|
|
64 /* TRACE */
|
|
)
|
|
)
|
|
});
|
|
}
|
|
function hasFlag(level, flag) {
|
|
return (level & flag) === flag;
|
|
}
|
|
function shouldLog(includes, level) {
|
|
return ((level & 32 /* PUBLIC */) === 32 /* PUBLIC */ ? true : (level & 16 /* DEV */) === 16 /* DEV */ ? includes.dev : (level & 8 /* INTERNAL */) === 8 /* INTERNAL */ ? includes.internal : false) && includes.min <= level;
|
|
}
|
|
var DEFAULTS = {
|
|
loggingConsoleStyle: true,
|
|
loggerConsoleStyle: true,
|
|
includes: Object.freeze({
|
|
internal: false,
|
|
dev: false,
|
|
min: 256 /* WARN */
|
|
}),
|
|
filtered: function defaultFiltered() {
|
|
},
|
|
include: function defaultInclude() {
|
|
return {};
|
|
},
|
|
create: null,
|
|
creatExt: null,
|
|
named(parent2, name, key) {
|
|
return this.create({
|
|
names: [...parent2.names, { name, key }]
|
|
});
|
|
},
|
|
style: {
|
|
bold: void 0,
|
|
// /Service$/
|
|
italic: void 0,
|
|
// /Model$/
|
|
cssMemo: /* @__PURE__ */ new Map([
|
|
// handle empty names so we don't have to check for
|
|
// name.length > 0 during this.css('')
|
|
["", ""]
|
|
// bring a specific override
|
|
// ["Marker", "color:#aea9ff;font-size:0.75em;text-transform:uppercase"]
|
|
]),
|
|
collapseOnRE: /[a-z- ]+/g,
|
|
color: void 0,
|
|
// create collapsed name
|
|
// insert collapsed name into cssMemo with original's style
|
|
collapsed(name) {
|
|
if (name.length < 5)
|
|
return name;
|
|
const collapsed = name.replace(this.collapseOnRE, "");
|
|
if (!this.cssMemo.has(collapsed)) {
|
|
this.cssMemo.set(collapsed, this.css(name));
|
|
}
|
|
return collapsed;
|
|
},
|
|
css(name) {
|
|
var _a, _b, _c, _d;
|
|
const found = this.cssMemo.get(name);
|
|
if (found)
|
|
return found;
|
|
let css = "color:".concat((_b = (_a = this.color) == null ? void 0 : _a.call(this, name)) != null ? _b : "hsl(".concat((name.charCodeAt(0) + name.charCodeAt(name.length - 1)) % 360, ", 100%, 60%)"));
|
|
if ((_c = this.bold) == null ? void 0 : _c.test(name)) {
|
|
css += ";font-weight:600";
|
|
}
|
|
if ((_d = this.italic) == null ? void 0 : _d.test(name)) {
|
|
css += ";font-style:italic";
|
|
}
|
|
this.cssMemo.set(name, css);
|
|
return css;
|
|
}
|
|
}
|
|
};
|
|
function createTheatreInternalLogger(useConsole = console, _options = {}) {
|
|
const ref = __spreadProps(__spreadValues({}, DEFAULTS), { includes: __spreadValues({}, DEFAULTS.includes) });
|
|
const createConsole = {
|
|
styled: createConsoleLoggerStyled.bind(ref, useConsole),
|
|
noStyle: createConsoleLoggerNoStyle.bind(ref, useConsole)
|
|
};
|
|
const createExtBound = createExtLogger.bind(ref);
|
|
function getConCreate() {
|
|
return ref.loggingConsoleStyle && ref.loggerConsoleStyle ? createConsole.styled : createConsole.noStyle;
|
|
}
|
|
ref.create = getConCreate();
|
|
return {
|
|
configureLogger(config) {
|
|
var _a;
|
|
if (config === "console") {
|
|
ref.loggerConsoleStyle = DEFAULTS.loggerConsoleStyle;
|
|
ref.create = getConCreate();
|
|
} else if (config.type === "console") {
|
|
ref.loggerConsoleStyle = (_a = config.style) != null ? _a : DEFAULTS.loggerConsoleStyle;
|
|
ref.create = getConCreate();
|
|
} else if (config.type === "keyed") {
|
|
ref.creatExt = (source) => config.keyed(source.names);
|
|
ref.create = createExtBound;
|
|
} else if (config.type === "named") {
|
|
ref.creatExt = configNamedToKeyed.bind(null, config.named);
|
|
ref.create = createExtBound;
|
|
}
|
|
},
|
|
configureLogging(config) {
|
|
var _a, _b, _c, _d, _e;
|
|
ref.includes.dev = (_a = config.dev) != null ? _a : DEFAULTS.includes.dev;
|
|
ref.includes.internal = (_b = config.internal) != null ? _b : DEFAULTS.includes.internal;
|
|
ref.includes.min = (_c = config.min) != null ? _c : DEFAULTS.includes.min;
|
|
ref.include = (_d = config.include) != null ? _d : DEFAULTS.include;
|
|
ref.loggingConsoleStyle = (_e = config.consoleStyle) != null ? _e : DEFAULTS.loggingConsoleStyle;
|
|
ref.create = getConCreate();
|
|
},
|
|
getLogger() {
|
|
return ref.create({ names: [] });
|
|
}
|
|
};
|
|
}
|
|
function configNamedToKeyed(namedFn, source) {
|
|
const names = [];
|
|
for (let { name, key } of source.names) {
|
|
names.push(key == null ? name : "".concat(name, " (").concat(key, ")"));
|
|
}
|
|
return namedFn(names);
|
|
}
|
|
function createExtLogger(source) {
|
|
const includes = __spreadValues(__spreadValues({}, this.includes), this.include(source));
|
|
const f2 = this.filtered;
|
|
const named = this.named.bind(this, source);
|
|
const ext = this.creatExt(source);
|
|
const _HMM = shouldLog(includes, 524 /* _HMM */);
|
|
const _TODO = shouldLog(includes, 522 /* _TODO */);
|
|
const _ERROR = shouldLog(includes, 521 /* _ERROR */);
|
|
const ERROR_DEV = shouldLog(includes, 529 /* ERROR_DEV */);
|
|
const ERROR_PUBLIC = shouldLog(includes, 545 /* ERROR_PUBLIC */);
|
|
const _WARN = shouldLog(includes, 265 /* _WARN */);
|
|
const _KAPOW = shouldLog(includes, 268 /* _KAPOW */);
|
|
const WARN_DEV = shouldLog(includes, 273 /* WARN_DEV */);
|
|
const WARN_PUBLIC = shouldLog(includes, 289 /* WARN_PUBLIC */);
|
|
const _DEBUG = shouldLog(includes, 137 /* _DEBUG */);
|
|
const DEBUG_DEV = shouldLog(includes, 145 /* DEBUG_DEV */);
|
|
const _TRACE = shouldLog(includes, 73 /* _TRACE */);
|
|
const TRACE_DEV = shouldLog(includes, 81 /* TRACE_DEV */);
|
|
const _hmm = _HMM ? ext.error.bind(ext, LEVELS._hmm) : f2.bind(source, 524 /* _HMM */);
|
|
const _todo = _TODO ? ext.error.bind(ext, LEVELS._todo) : f2.bind(source, 522 /* _TODO */);
|
|
const _error = _ERROR ? ext.error.bind(ext, LEVELS._error) : f2.bind(source, 521 /* _ERROR */);
|
|
const errorDev = ERROR_DEV ? ext.error.bind(ext, LEVELS.errorDev) : f2.bind(source, 529 /* ERROR_DEV */);
|
|
const errorPublic = ERROR_PUBLIC ? ext.error.bind(ext, LEVELS.errorPublic) : f2.bind(source, 545 /* ERROR_PUBLIC */);
|
|
const _kapow = _KAPOW ? ext.warn.bind(ext, LEVELS._kapow) : f2.bind(source, 268 /* _KAPOW */);
|
|
const _warn = _WARN ? ext.warn.bind(ext, LEVELS._warn) : f2.bind(source, 265 /* _WARN */);
|
|
const warnDev = WARN_DEV ? ext.warn.bind(ext, LEVELS.warnDev) : f2.bind(source, 273 /* WARN_DEV */);
|
|
const warnPublic = WARN_PUBLIC ? ext.warn.bind(ext, LEVELS.warnPublic) : f2.bind(source, 273 /* WARN_DEV */);
|
|
const _debug = _DEBUG ? ext.debug.bind(ext, LEVELS._debug) : f2.bind(source, 137 /* _DEBUG */);
|
|
const debugDev = DEBUG_DEV ? ext.debug.bind(ext, LEVELS.debugDev) : f2.bind(source, 145 /* DEBUG_DEV */);
|
|
const _trace = _TRACE ? ext.trace.bind(ext, LEVELS._trace) : f2.bind(source, 73 /* _TRACE */);
|
|
const traceDev = TRACE_DEV ? ext.trace.bind(ext, LEVELS.traceDev) : f2.bind(source, 81 /* TRACE_DEV */);
|
|
const logger = {
|
|
_hmm,
|
|
_todo,
|
|
_error,
|
|
errorDev,
|
|
errorPublic,
|
|
_kapow,
|
|
_warn,
|
|
warnDev,
|
|
warnPublic,
|
|
_debug,
|
|
debugDev,
|
|
_trace,
|
|
traceDev,
|
|
lazy: {
|
|
_hmm: _HMM ? lazy(_hmm) : _hmm,
|
|
_todo: _TODO ? lazy(_todo) : _todo,
|
|
_error: _ERROR ? lazy(_error) : _error,
|
|
errorDev: ERROR_DEV ? lazy(errorDev) : errorDev,
|
|
errorPublic: ERROR_PUBLIC ? lazy(errorPublic) : errorPublic,
|
|
_kapow: _KAPOW ? lazy(_kapow) : _kapow,
|
|
_warn: _WARN ? lazy(_warn) : _warn,
|
|
warnDev: WARN_DEV ? lazy(warnDev) : warnDev,
|
|
warnPublic: WARN_PUBLIC ? lazy(warnPublic) : warnPublic,
|
|
_debug: _DEBUG ? lazy(_debug) : _debug,
|
|
debugDev: DEBUG_DEV ? lazy(debugDev) : debugDev,
|
|
_trace: _TRACE ? lazy(_trace) : _trace,
|
|
traceDev: TRACE_DEV ? lazy(traceDev) : traceDev
|
|
},
|
|
//
|
|
named,
|
|
utilFor: {
|
|
internal() {
|
|
return {
|
|
debug: logger._debug,
|
|
error: logger._error,
|
|
warn: logger._warn,
|
|
trace: logger._trace,
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.internal();
|
|
}
|
|
};
|
|
},
|
|
dev() {
|
|
return {
|
|
debug: logger.debugDev,
|
|
error: logger.errorDev,
|
|
warn: logger.warnDev,
|
|
trace: logger.traceDev,
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.dev();
|
|
}
|
|
};
|
|
},
|
|
public() {
|
|
return {
|
|
error: logger.errorPublic,
|
|
warn: logger.warnPublic,
|
|
debug(message, obj) {
|
|
logger._warn('(public "debug" filtered out) '.concat(message), obj);
|
|
},
|
|
trace(message, obj) {
|
|
logger._warn('(public "trace" filtered out) '.concat(message), obj);
|
|
},
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.public();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
};
|
|
return logger;
|
|
}
|
|
function createConsoleLoggerStyled(con, source) {
|
|
const includes = __spreadValues(__spreadValues({}, this.includes), this.include(source));
|
|
const styleArgs = [];
|
|
let prefix = "";
|
|
for (let i2 = 0; i2 < source.names.length; i2++) {
|
|
const { name, key } = source.names[i2];
|
|
prefix += " %c".concat(name);
|
|
styleArgs.push(this.style.css(name));
|
|
if (key != null) {
|
|
const keyStr = "%c#".concat(key);
|
|
prefix += keyStr;
|
|
styleArgs.push(this.style.css(keyStr));
|
|
}
|
|
}
|
|
const f2 = this.filtered;
|
|
const named = this.named.bind(this, source);
|
|
const prefixArr = [prefix, ...styleArgs];
|
|
return _createConsoleLogger(
|
|
f2,
|
|
source,
|
|
includes,
|
|
con,
|
|
prefixArr,
|
|
styledKapowPrefix(prefixArr),
|
|
named
|
|
);
|
|
}
|
|
function styledKapowPrefix(args) {
|
|
const start = args.slice(0);
|
|
for (let i2 = 1; i2 < start.length; i2++)
|
|
start[i2] += ";background-color:#e0005a;padding:2px;color:white";
|
|
return start;
|
|
}
|
|
function createConsoleLoggerNoStyle(con, source) {
|
|
const includes = __spreadValues(__spreadValues({}, this.includes), this.include(source));
|
|
let prefix = "";
|
|
for (let i2 = 0; i2 < source.names.length; i2++) {
|
|
const { name, key } = source.names[i2];
|
|
prefix += " ".concat(name);
|
|
if (key != null) {
|
|
prefix += "#".concat(key);
|
|
}
|
|
}
|
|
const f2 = this.filtered;
|
|
const named = this.named.bind(this, source);
|
|
const prefixArr = [prefix];
|
|
return _createConsoleLogger(
|
|
f2,
|
|
source,
|
|
includes,
|
|
con,
|
|
prefixArr,
|
|
prefixArr,
|
|
named
|
|
);
|
|
}
|
|
function _createConsoleLogger(f2, source, includes, con, prefix, kapowPrefix, named) {
|
|
const _HMM = shouldLog(includes, 524 /* _HMM */);
|
|
const _TODO = shouldLog(includes, 522 /* _TODO */);
|
|
const _ERROR = shouldLog(includes, 521 /* _ERROR */);
|
|
const ERROR_DEV = shouldLog(includes, 529 /* ERROR_DEV */);
|
|
const ERROR_PUBLIC = shouldLog(includes, 545 /* ERROR_PUBLIC */);
|
|
const _WARN = shouldLog(includes, 265 /* _WARN */);
|
|
const _KAPOW = shouldLog(includes, 268 /* _KAPOW */);
|
|
const WARN_DEV = shouldLog(includes, 273 /* WARN_DEV */);
|
|
const WARN_PUBLIC = shouldLog(includes, 289 /* WARN_PUBLIC */);
|
|
const _DEBUG = shouldLog(includes, 137 /* _DEBUG */);
|
|
const DEBUG_DEV = shouldLog(includes, 145 /* DEBUG_DEV */);
|
|
const _TRACE = shouldLog(includes, 73 /* _TRACE */);
|
|
const TRACE_DEV = shouldLog(includes, 81 /* TRACE_DEV */);
|
|
const _hmm = _HMM ? con.error.bind(con, ...prefix) : f2.bind(source, 524 /* _HMM */);
|
|
const _todo = _TODO ? con.error.bind(con, ...prefix) : f2.bind(source, 522 /* _TODO */);
|
|
const _error = _ERROR ? con.error.bind(con, ...prefix) : f2.bind(source, 521 /* _ERROR */);
|
|
const errorDev = ERROR_DEV ? con.error.bind(con, ...prefix) : f2.bind(source, 529 /* ERROR_DEV */);
|
|
const errorPublic = ERROR_PUBLIC ? con.error.bind(con, ...prefix) : f2.bind(source, 545 /* ERROR_PUBLIC */);
|
|
const _kapow = _KAPOW ? con.warn.bind(con, ...kapowPrefix) : f2.bind(source, 268 /* _KAPOW */);
|
|
const _warn = _WARN ? con.warn.bind(con, ...prefix) : f2.bind(source, 265 /* _WARN */);
|
|
const warnDev = WARN_DEV ? con.warn.bind(con, ...prefix) : f2.bind(source, 273 /* WARN_DEV */);
|
|
const warnPublic = WARN_PUBLIC ? con.warn.bind(con, ...prefix) : f2.bind(source, 273 /* WARN_DEV */);
|
|
const _debug = _DEBUG ? con.info.bind(con, ...prefix) : f2.bind(source, 137 /* _DEBUG */);
|
|
const debugDev = DEBUG_DEV ? con.info.bind(con, ...prefix) : f2.bind(source, 145 /* DEBUG_DEV */);
|
|
const _trace = _TRACE ? con.debug.bind(con, ...prefix) : f2.bind(source, 73 /* _TRACE */);
|
|
const traceDev = TRACE_DEV ? con.debug.bind(con, ...prefix) : f2.bind(source, 81 /* TRACE_DEV */);
|
|
const logger = {
|
|
_hmm,
|
|
_todo,
|
|
_error,
|
|
errorDev,
|
|
errorPublic,
|
|
_kapow,
|
|
_warn,
|
|
warnDev,
|
|
warnPublic,
|
|
_debug,
|
|
debugDev,
|
|
_trace,
|
|
traceDev,
|
|
lazy: {
|
|
_hmm: _HMM ? lazy(_hmm) : _hmm,
|
|
_todo: _TODO ? lazy(_todo) : _todo,
|
|
_error: _ERROR ? lazy(_error) : _error,
|
|
errorDev: ERROR_DEV ? lazy(errorDev) : errorDev,
|
|
errorPublic: ERROR_PUBLIC ? lazy(errorPublic) : errorPublic,
|
|
_kapow: _KAPOW ? lazy(_kapow) : _kapow,
|
|
_warn: _WARN ? lazy(_warn) : _warn,
|
|
warnDev: WARN_DEV ? lazy(warnDev) : warnDev,
|
|
warnPublic: WARN_PUBLIC ? lazy(warnPublic) : warnPublic,
|
|
_debug: _DEBUG ? lazy(_debug) : _debug,
|
|
debugDev: DEBUG_DEV ? lazy(debugDev) : debugDev,
|
|
_trace: _TRACE ? lazy(_trace) : _trace,
|
|
traceDev: TRACE_DEV ? lazy(traceDev) : traceDev
|
|
},
|
|
//
|
|
named,
|
|
utilFor: {
|
|
internal() {
|
|
return {
|
|
debug: logger._debug,
|
|
error: logger._error,
|
|
warn: logger._warn,
|
|
trace: logger._trace,
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.internal();
|
|
}
|
|
};
|
|
},
|
|
dev() {
|
|
return {
|
|
debug: logger.debugDev,
|
|
error: logger.errorDev,
|
|
warn: logger.warnDev,
|
|
trace: logger.traceDev,
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.dev();
|
|
}
|
|
};
|
|
},
|
|
public() {
|
|
return {
|
|
error: logger.errorPublic,
|
|
warn: logger.warnPublic,
|
|
debug(message, obj) {
|
|
logger._warn('(public "debug" filtered out) '.concat(message), obj);
|
|
},
|
|
trace(message, obj) {
|
|
logger._warn('(public "trace" filtered out) '.concat(message), obj);
|
|
},
|
|
named(name, key) {
|
|
return logger.named(name, key).utilFor.public();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
};
|
|
return logger;
|
|
}
|
|
|
|
// shared/src/logger.ts
|
|
var internal = createTheatreInternalLogger(console, {
|
|
_debug: function() {
|
|
},
|
|
_error: function() {
|
|
}
|
|
});
|
|
internal.configureLogging({
|
|
dev: true,
|
|
min: 64 /* TRACE */
|
|
});
|
|
var logger_default = internal.getLogger().named("Theatre.js (default logger)").utilFor.dev();
|
|
|
|
// core/src/sheetObjects/getOrderingOfPropTypeConfig.ts
|
|
var cache = /* @__PURE__ */ new WeakMap();
|
|
function getOrderingOfPropTypeConfig(config) {
|
|
const existing = cache.get(config);
|
|
if (existing)
|
|
return existing;
|
|
const map = /* @__PURE__ */ new Map();
|
|
cache.set(config, map);
|
|
iterateOnCompound([], config, map);
|
|
return map;
|
|
}
|
|
function iterateOnCompound(path, config, map) {
|
|
for (const [key, subConf] of Object.entries(config.props)) {
|
|
if (!isPropConfigComposite(subConf)) {
|
|
const subPath = [...path, key];
|
|
map.set(JSON.stringify(subPath), map.size);
|
|
iterateOnAny(subPath, subConf, map);
|
|
}
|
|
}
|
|
for (const [key, subConf] of Object.entries(config.props)) {
|
|
if (isPropConfigComposite(subConf)) {
|
|
const subPath = [...path, key];
|
|
map.set(JSON.stringify(subPath), map.size);
|
|
iterateOnAny(subPath, subConf, map);
|
|
}
|
|
}
|
|
}
|
|
function iterateOnAny(path, config, map) {
|
|
if (config.type === "compound") {
|
|
iterateOnCompound(path, config, map);
|
|
} else if (config.type === "enum") {
|
|
throw new Error("Enums aren't supported yet");
|
|
} else {
|
|
map.set(JSON.stringify(path), map.size);
|
|
}
|
|
}
|
|
|
|
// core/src/sheetObjects/SheetObjectTemplate.ts
|
|
function isObjectEmpty(obj) {
|
|
return typeof obj === "object" && obj !== null && Object.keys(obj).length === 0;
|
|
}
|
|
var SheetObjectTemplate = class {
|
|
constructor(sheetTemplate, objectKey, nativeObject, config, _temp_actions) {
|
|
this.sheetTemplate = sheetTemplate;
|
|
__publicField(this, "address");
|
|
__publicField(this, "type", "Theatre_SheetObjectTemplate");
|
|
__publicField(this, "_config");
|
|
__publicField(this, "_temp_actions_atom");
|
|
__publicField(this, "_cache", new SimpleCache());
|
|
__publicField(this, "project");
|
|
__publicField(this, "pointerToSheetState");
|
|
__publicField(this, "pointerToStaticOverrides");
|
|
this.address = __spreadProps(__spreadValues({}, sheetTemplate.address), { objectKey });
|
|
this._config = new import_dataverse6.Atom(config);
|
|
this._temp_actions_atom = new import_dataverse6.Atom(_temp_actions);
|
|
this.project = sheetTemplate.project;
|
|
this.pointerToSheetState = this.sheetTemplate.project.pointers.historic.sheetsById[this.address.sheetId];
|
|
this.pointerToStaticOverrides = this.pointerToSheetState.staticOverrides.byObject[this.address.objectKey];
|
|
}
|
|
get staticConfig() {
|
|
return this._config.get();
|
|
}
|
|
get configPointer() {
|
|
return this._config.pointer;
|
|
}
|
|
get _temp_actions() {
|
|
return this._temp_actions_atom.get();
|
|
}
|
|
get _temp_actionsPointer() {
|
|
return this._temp_actions_atom.pointer;
|
|
}
|
|
createInstance(sheet, nativeObject, config) {
|
|
this._config.set(config);
|
|
return new SheetObject(sheet, this, nativeObject);
|
|
}
|
|
reconfigure(config) {
|
|
this._config.set(config);
|
|
}
|
|
/**
|
|
* The `actions` api is temporary until we implement events.
|
|
*/
|
|
_temp_setActions(actions) {
|
|
this._temp_actions_atom.set(actions);
|
|
}
|
|
/**
|
|
* Returns the default values (all defaults are read from the config)
|
|
*/
|
|
getDefaultValues() {
|
|
return this._cache.get(
|
|
"getDefaultValues()",
|
|
() => (0, import_dataverse6.prism)(() => {
|
|
const config = (0, import_dataverse6.val)(this.configPointer);
|
|
return getPropDefaultsOfSheetObject(config);
|
|
})
|
|
);
|
|
}
|
|
/**
|
|
* Returns values that are set statically (ie, not sequenced, and not defaults)
|
|
*/
|
|
getStaticValues() {
|
|
return this._cache.get(
|
|
"getStaticValues",
|
|
() => (0, import_dataverse6.prism)(() => {
|
|
var _a;
|
|
const json = (_a = (0, import_dataverse6.val)(this.pointerToStaticOverrides)) != null ? _a : {};
|
|
const config = (0, import_dataverse6.val)(this.configPointer);
|
|
const deserialized = config.deserializeAndSanitize(json) || {};
|
|
return deserialized;
|
|
})
|
|
);
|
|
}
|
|
/**
|
|
* Filters through the sequenced tracks and returns those tracks who are valid
|
|
* according to the object's prop types, then sorted in the same order as the config
|
|
*
|
|
* Returns an array.
|
|
*/
|
|
getArrayOfValidSequenceTracks() {
|
|
return this._cache.get(
|
|
"getArrayOfValidSequenceTracks",
|
|
() => (0, import_dataverse6.prism)(() => {
|
|
const pointerToSheetState = this.project.pointers.historic.sheetsById[this.address.sheetId];
|
|
const trackIdByPropPath = (0, import_dataverse6.val)(
|
|
pointerToSheetState.sequence.tracksByObject[this.address.objectKey].trackIdByPropPath
|
|
);
|
|
if (!trackIdByPropPath)
|
|
return emptyArray;
|
|
const arrayOfIds = [];
|
|
if (!trackIdByPropPath)
|
|
return emptyArray;
|
|
const objectConfig = (0, import_dataverse6.val)(this.configPointer);
|
|
const _entries = Object.entries(trackIdByPropPath);
|
|
for (const [pathToPropInString, trackId] of _entries) {
|
|
const pathToProp = parsePathToProp(pathToPropInString);
|
|
if (!pathToProp)
|
|
continue;
|
|
const propConfig = getPropConfigByPath(objectConfig, pathToProp);
|
|
const isSequencable = propConfig && isPropConfSequencable(propConfig);
|
|
if (!isSequencable)
|
|
continue;
|
|
arrayOfIds.push({ pathToProp, trackId });
|
|
}
|
|
const mapping = getOrderingOfPropTypeConfig(objectConfig);
|
|
arrayOfIds.sort((a2, b2) => {
|
|
const pathToPropA = a2.pathToProp;
|
|
const pathToPropB = b2.pathToProp;
|
|
const indexA = mapping.get(JSON.stringify(pathToPropA));
|
|
const indexB = mapping.get(JSON.stringify(pathToPropB));
|
|
if (indexA > indexB) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
});
|
|
if (arrayOfIds.length === 0) {
|
|
return emptyArray;
|
|
} else {
|
|
return arrayOfIds;
|
|
}
|
|
})
|
|
);
|
|
}
|
|
/**
|
|
* Filters through the sequenced tracks those tracks that are valid
|
|
* according to the object's prop types.
|
|
*
|
|
* Returns a map.
|
|
*
|
|
* Not available in core.
|
|
*/
|
|
getMapOfValidSequenceTracks_forStudio() {
|
|
return this._cache.get(
|
|
"getMapOfValidSequenceTracks_forStudio",
|
|
() => (0, import_dataverse6.prism)(() => {
|
|
const arr = (0, import_dataverse6.val)(this.getArrayOfValidSequenceTracks());
|
|
let map = {};
|
|
for (const { pathToProp, trackId } of arr) {
|
|
set_default(map, pathToProp, trackId);
|
|
}
|
|
return map;
|
|
})
|
|
);
|
|
}
|
|
/**
|
|
* @returns The static overrides that are not sequenced. Returns undefined if there are no static overrides,
|
|
* or if all those static overrides are sequenced.
|
|
*/
|
|
getStaticButNotSequencedOverrides() {
|
|
return this._cache.get(
|
|
"getStaticButNotSequencedOverrides",
|
|
() => (0, import_dataverse6.prism)(() => {
|
|
const staticOverrides = (0, import_dataverse6.val)(this.getStaticValues());
|
|
const arrayOfValidSequenceTracks = (0, import_dataverse6.val)(
|
|
this.getArrayOfValidSequenceTracks()
|
|
);
|
|
const staticButNotSequencedOverrides = cloneDeep_default(staticOverrides);
|
|
for (const { pathToProp } of arrayOfValidSequenceTracks) {
|
|
unset_default(staticButNotSequencedOverrides, pathToProp);
|
|
let parentPath = pathToProp.slice(0, -1);
|
|
while (parentPath.length > 0) {
|
|
const parentValue = getDeep(
|
|
staticButNotSequencedOverrides,
|
|
parentPath
|
|
);
|
|
if (!isObjectEmpty(parentValue))
|
|
break;
|
|
unset_default(staticButNotSequencedOverrides, parentPath);
|
|
parentPath = parentPath.slice(0, -1);
|
|
}
|
|
}
|
|
if (isObjectEmpty(staticButNotSequencedOverrides)) {
|
|
return void 0;
|
|
} else {
|
|
return staticButNotSequencedOverrides;
|
|
}
|
|
})
|
|
);
|
|
}
|
|
getDefaultsAtPointer(pointer3) {
|
|
const { path } = (0, import_dataverse6.getPointerParts)(pointer3);
|
|
const defaults = this.getDefaultValues().getValue();
|
|
const defaultsAtPath = getDeep(defaults, path);
|
|
return defaultsAtPath;
|
|
}
|
|
};
|
|
function parsePathToProp(pathToPropInString) {
|
|
try {
|
|
const pathToProp = JSON.parse(pathToPropInString);
|
|
return pathToProp;
|
|
} catch (e2) {
|
|
logger_default.warn(
|
|
"property ".concat(JSON.stringify(
|
|
pathToPropInString
|
|
), " cannot be parsed. Skipping.")
|
|
);
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// core/src/sheets/SheetTemplate.ts
|
|
var import_dataverse15 = require("@theatre/dataverse");
|
|
|
|
// shared/src/utils/addresses.ts
|
|
var encodePathToProp = memoizeFn(
|
|
(p2) => (
|
|
// we're using JSON.stringify here, but we could use a faster alternative.
|
|
// If you happen to do that, first make sure no `PathToProp_Encoded` is ever
|
|
// used in the store, otherwise you'll have to write a migration.
|
|
JSON.stringify(p2)
|
|
)
|
|
);
|
|
|
|
// shared/src/utils/didYouMean.ts
|
|
var import_propose = __toESM(require_propose());
|
|
function didYouMean(str, dictionary, prepend = "Did you mean ", append = "?") {
|
|
const p2 = (0, import_propose.default)(str, dictionary, {
|
|
threshold: 0.7
|
|
});
|
|
if (p2) {
|
|
return prepend + JSON.stringify(p2) + append;
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// shared/src/utils/errors.ts
|
|
var TheatreError = class extends Error {
|
|
};
|
|
var InvalidArgumentError = class extends TheatreError {
|
|
};
|
|
|
|
// core/src/sequences/Sequence.ts
|
|
var import_dataverse10 = require("@theatre/dataverse");
|
|
var import_dataverse11 = require("@theatre/dataverse");
|
|
var import_dataverse12 = require("@theatre/dataverse");
|
|
var import_dataverse13 = require("@theatre/dataverse");
|
|
|
|
// shared/src/utils/defer.ts
|
|
function defer() {
|
|
let resolve;
|
|
let reject;
|
|
const promise = new Promise((rs, rj) => {
|
|
resolve = (v2) => {
|
|
rs(v2);
|
|
deferred.status = "resolved";
|
|
};
|
|
reject = (v2) => {
|
|
rj(v2);
|
|
deferred.status = "rejected";
|
|
};
|
|
});
|
|
const deferred = {
|
|
resolve,
|
|
reject,
|
|
promise,
|
|
status: "pending"
|
|
};
|
|
return deferred;
|
|
}
|
|
|
|
// shared/src/utils/noop.ts
|
|
var noop = () => {
|
|
};
|
|
var noop_default = noop;
|
|
|
|
// core/src/sequences/playbackControllers/DefaultPlaybackController.ts
|
|
var import_dataverse7 = require("@theatre/dataverse");
|
|
var DefaultPlaybackController = class {
|
|
constructor() {
|
|
__publicField(this, "_stopPlayCallback", noop_default);
|
|
__publicField(this, "_state", new import_dataverse7.Atom({
|
|
position: 0,
|
|
playing: false
|
|
}));
|
|
__publicField(this, "statePointer");
|
|
this.statePointer = this._state.pointer;
|
|
}
|
|
destroy() {
|
|
}
|
|
pause() {
|
|
this._stopPlayCallback();
|
|
this.playing = false;
|
|
this._stopPlayCallback = noop_default;
|
|
}
|
|
gotoPosition(time) {
|
|
this._updatePositionInState(time);
|
|
}
|
|
_updatePositionInState(time) {
|
|
this._state.setByPointer((p2) => p2.position, time);
|
|
}
|
|
getCurrentPosition() {
|
|
return this._state.get().position;
|
|
}
|
|
get playing() {
|
|
return this._state.get().playing;
|
|
}
|
|
set playing(playing) {
|
|
this._state.setByPointer((p2) => p2.playing, playing);
|
|
}
|
|
play(iterationCount, range, rate, direction, ticker) {
|
|
if (this.playing) {
|
|
this.pause();
|
|
}
|
|
this.playing = true;
|
|
const iterationLength = range[1] - range[0];
|
|
{
|
|
const startPos = this.getCurrentPosition();
|
|
if (startPos < range[0] || startPos > range[1]) {
|
|
if (direction === "normal" || direction === "alternate") {
|
|
this._updatePositionInState(range[0]);
|
|
} else if (direction === "reverse" || direction === "alternateReverse") {
|
|
this._updatePositionInState(range[1]);
|
|
}
|
|
} else if (direction === "normal" || direction === "alternate") {
|
|
if (startPos === range[1]) {
|
|
this._updatePositionInState(range[0]);
|
|
}
|
|
} else {
|
|
if (startPos === range[0]) {
|
|
this._updatePositionInState(range[1]);
|
|
}
|
|
}
|
|
}
|
|
const deferred = defer();
|
|
const initialTickerTime = ticker.time;
|
|
const totalPlaybackLength = iterationLength * iterationCount;
|
|
let initialElapsedPos = this.getCurrentPosition() - range[0];
|
|
if (direction === "reverse" || direction === "alternateReverse") {
|
|
initialElapsedPos = range[1] - this.getCurrentPosition();
|
|
}
|
|
const tick = (currentTickerTime) => {
|
|
const elapsedTickerTime = Math.max(
|
|
currentTickerTime - initialTickerTime,
|
|
0
|
|
);
|
|
const elapsedTickerTimeInSeconds = elapsedTickerTime / 1e3;
|
|
const elapsedPos = Math.min(
|
|
elapsedTickerTimeInSeconds * rate + initialElapsedPos,
|
|
totalPlaybackLength
|
|
);
|
|
if (elapsedPos !== totalPlaybackLength) {
|
|
const iterationNumber = Math.floor(elapsedPos / iterationLength);
|
|
let currentIterationPos = elapsedPos / iterationLength % 1 * iterationLength;
|
|
if (direction !== "normal") {
|
|
if (direction === "reverse") {
|
|
currentIterationPos = iterationLength - currentIterationPos;
|
|
} else {
|
|
const isCurrentIterationNumberEven = iterationNumber % 2 === 0;
|
|
if (direction === "alternate") {
|
|
if (!isCurrentIterationNumberEven) {
|
|
currentIterationPos = iterationLength - currentIterationPos;
|
|
}
|
|
} else {
|
|
if (isCurrentIterationNumberEven) {
|
|
currentIterationPos = iterationLength - currentIterationPos;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this._updatePositionInState(currentIterationPos + range[0]);
|
|
requestNextTick();
|
|
} else {
|
|
if (direction === "normal") {
|
|
this._updatePositionInState(range[1]);
|
|
} else if (direction === "reverse") {
|
|
this._updatePositionInState(range[0]);
|
|
} else {
|
|
const isLastIterationEven = (iterationCount - 1) % 2 === 0;
|
|
if (direction === "alternate") {
|
|
if (isLastIterationEven) {
|
|
this._updatePositionInState(range[1]);
|
|
} else {
|
|
this._updatePositionInState(range[0]);
|
|
}
|
|
} else {
|
|
if (isLastIterationEven) {
|
|
this._updatePositionInState(range[0]);
|
|
} else {
|
|
this._updatePositionInState(range[1]);
|
|
}
|
|
}
|
|
}
|
|
this.playing = false;
|
|
deferred.resolve(true);
|
|
}
|
|
};
|
|
this._stopPlayCallback = () => {
|
|
ticker.offThisOrNextTick(tick);
|
|
ticker.offNextTick(tick);
|
|
if (this.playing)
|
|
deferred.resolve(false);
|
|
};
|
|
const requestNextTick = () => ticker.onNextTick(tick);
|
|
ticker.onThisOrNextTick(tick);
|
|
return deferred.promise;
|
|
}
|
|
playDynamicRange(rangeD, ticker) {
|
|
if (this.playing) {
|
|
this.pause();
|
|
}
|
|
this.playing = true;
|
|
const deferred = defer();
|
|
const untapFromRangeD = rangeD.keepHot();
|
|
void deferred.promise.then(untapFromRangeD, untapFromRangeD);
|
|
let lastTickerTime = ticker.time;
|
|
const tick = (currentTickerTime) => {
|
|
const elapsedSinceLastTick = Math.max(
|
|
currentTickerTime - lastTickerTime,
|
|
0
|
|
);
|
|
lastTickerTime = currentTickerTime;
|
|
const elapsedSinceLastTickInSeconds = elapsedSinceLastTick / 1e3;
|
|
const lastPosition = this.getCurrentPosition();
|
|
const range = rangeD.getValue();
|
|
if (lastPosition < range[0] || lastPosition > range[1]) {
|
|
this.gotoPosition(range[0]);
|
|
} else {
|
|
let newPosition = lastPosition + elapsedSinceLastTickInSeconds;
|
|
if (newPosition > range[1]) {
|
|
newPosition = range[0] + (newPosition - range[1]);
|
|
}
|
|
this.gotoPosition(newPosition);
|
|
}
|
|
requestNextTick();
|
|
};
|
|
this._stopPlayCallback = () => {
|
|
ticker.offThisOrNextTick(tick);
|
|
ticker.offNextTick(tick);
|
|
deferred.resolve(false);
|
|
};
|
|
const requestNextTick = () => ticker.onNextTick(tick);
|
|
ticker.onThisOrNextTick(tick);
|
|
return deferred.promise;
|
|
}
|
|
};
|
|
|
|
// core/src/sequences/playbackControllers/AudioPlaybackController.ts
|
|
var import_dataverse8 = require("@theatre/dataverse");
|
|
|
|
// shared/src/globalVariableNames.ts
|
|
var studioBundle = "__TheatreJS_StudioBundle";
|
|
var coreBundle = "__TheatreJS_CoreBundle";
|
|
var notifications = "__TheatreJS_Notifications";
|
|
|
|
// shared/src/notify.ts
|
|
var createHandler = (type) => (...args) => {
|
|
var _a;
|
|
switch (type) {
|
|
case "success": {
|
|
logger_default.debug(args.slice(0, 2).join("\n"));
|
|
break;
|
|
}
|
|
case "info": {
|
|
logger_default.debug(args.slice(0, 2).join("\n"));
|
|
break;
|
|
}
|
|
case "warning": {
|
|
logger_default.warn(args.slice(0, 2).join("\n"));
|
|
break;
|
|
}
|
|
case "error": {
|
|
}
|
|
}
|
|
return typeof window !== "undefined" ? (
|
|
// @ts-ignore
|
|
(_a = window[notifications]) == null ? void 0 : _a.notify[type](...args)
|
|
) : void 0;
|
|
};
|
|
var notify = {
|
|
warning: createHandler("warning"),
|
|
success: createHandler("success"),
|
|
info: createHandler("info"),
|
|
error: createHandler("error")
|
|
};
|
|
if (typeof window !== "undefined") {
|
|
window.addEventListener("error", (e2) => {
|
|
notify.error(
|
|
"An error occurred",
|
|
"<pre>".concat(e2.message, "</pre>\n\nSee **console** for details.")
|
|
);
|
|
});
|
|
window.addEventListener("unhandledrejection", (e2) => {
|
|
notify.error(
|
|
"An error occurred",
|
|
"<pre>".concat(e2.reason, "</pre>\n\nSee **console** for details.")
|
|
);
|
|
});
|
|
}
|
|
|
|
// core/src/sequences/playbackControllers/AudioPlaybackController.ts
|
|
var AudioPlaybackController = class {
|
|
constructor(_decodedBuffer, _audioContext, _nodeDestination) {
|
|
this._decodedBuffer = _decodedBuffer;
|
|
this._audioContext = _audioContext;
|
|
this._nodeDestination = _nodeDestination;
|
|
__publicField(this, "_mainGain");
|
|
__publicField(this, "_state", new import_dataverse8.Atom({
|
|
position: 0,
|
|
playing: false
|
|
}));
|
|
__publicField(this, "statePointer");
|
|
__publicField(this, "_stopPlayCallback", noop_default);
|
|
this.statePointer = this._state.pointer;
|
|
this._mainGain = this._audioContext.createGain();
|
|
this._mainGain.connect(this._nodeDestination);
|
|
}
|
|
playDynamicRange(rangeD, ticker) {
|
|
const deferred = defer();
|
|
if (this._playing)
|
|
this.pause();
|
|
this._playing = true;
|
|
let stop = void 0;
|
|
const play = () => {
|
|
stop == null ? void 0 : stop();
|
|
stop = this._loopInRange(rangeD.getValue(), ticker).stop;
|
|
};
|
|
const untapFromRangeD = rangeD.onStale(play);
|
|
play();
|
|
this._stopPlayCallback = () => {
|
|
stop == null ? void 0 : stop();
|
|
untapFromRangeD();
|
|
deferred.resolve(false);
|
|
};
|
|
return deferred.promise;
|
|
}
|
|
_loopInRange(range, ticker) {
|
|
const rate = 1;
|
|
let startPos = this.getCurrentPosition();
|
|
const iterationLength = range[1] - range[0];
|
|
if (startPos < range[0] || startPos > range[1]) {
|
|
this._updatePositionInState(range[0]);
|
|
} else if (startPos === range[1]) {
|
|
this._updatePositionInState(range[0]);
|
|
}
|
|
startPos = this.getCurrentPosition();
|
|
const currentSource = this._audioContext.createBufferSource();
|
|
currentSource.buffer = this._decodedBuffer;
|
|
currentSource.connect(this._mainGain);
|
|
currentSource.playbackRate.value = rate;
|
|
currentSource.loop = true;
|
|
currentSource.loopStart = range[0];
|
|
currentSource.loopEnd = range[1];
|
|
const initialTickerTime = ticker.time;
|
|
let initialElapsedPos = startPos - range[0];
|
|
currentSource.start(0, startPos);
|
|
const tick = (currentTickerTime) => {
|
|
const elapsedTickerTime = Math.max(
|
|
currentTickerTime - initialTickerTime,
|
|
0
|
|
);
|
|
const elapsedTickerTimeInSeconds = elapsedTickerTime / 1e3;
|
|
const elapsedPos = elapsedTickerTimeInSeconds * rate + initialElapsedPos;
|
|
let currentIterationPos = elapsedPos / iterationLength % 1 * iterationLength;
|
|
this._updatePositionInState(currentIterationPos + range[0]);
|
|
requestNextTick();
|
|
};
|
|
const requestNextTick = () => ticker.onNextTick(tick);
|
|
ticker.onThisOrNextTick(tick);
|
|
const stop = () => {
|
|
currentSource.stop();
|
|
currentSource.disconnect();
|
|
ticker.offThisOrNextTick(tick);
|
|
ticker.offNextTick(tick);
|
|
};
|
|
return { stop };
|
|
}
|
|
get _playing() {
|
|
return this._state.get().playing;
|
|
}
|
|
set _playing(playing) {
|
|
this._state.setByPointer((p2) => p2.playing, playing);
|
|
}
|
|
destroy() {
|
|
}
|
|
pause() {
|
|
this._stopPlayCallback();
|
|
this._playing = false;
|
|
this._stopPlayCallback = noop_default;
|
|
}
|
|
gotoPosition(time) {
|
|
this._updatePositionInState(time);
|
|
}
|
|
_updatePositionInState(time) {
|
|
this._state.reduce((s2) => __spreadProps(__spreadValues({}, s2), { position: time }));
|
|
}
|
|
getCurrentPosition() {
|
|
return this._state.get().position;
|
|
}
|
|
play(iterationCount, range, rate, direction, ticker) {
|
|
if (this._playing) {
|
|
this.pause();
|
|
}
|
|
this._playing = true;
|
|
let startPos = this.getCurrentPosition();
|
|
const iterationLength = range[1] - range[0];
|
|
if (direction !== "normal") {
|
|
throw new InvalidArgumentError(
|
|
'Audio-controlled sequences can only be played in the "normal" direction. ' + "'".concat(direction, "' given.")
|
|
);
|
|
}
|
|
if (startPos < range[0] || startPos > range[1]) {
|
|
this._updatePositionInState(range[0]);
|
|
} else if (startPos === range[1]) {
|
|
this._updatePositionInState(range[0]);
|
|
}
|
|
startPos = this.getCurrentPosition();
|
|
const deferred = defer();
|
|
const currentSource = this._audioContext.createBufferSource();
|
|
currentSource.buffer = this._decodedBuffer;
|
|
currentSource.connect(this._mainGain);
|
|
currentSource.playbackRate.value = rate;
|
|
if (iterationCount > 1e3) {
|
|
notify.warning(
|
|
"Can't play sequences with audio more than 1000 times",
|
|
"The sequence will still play, but only 1000 times. The `iterationCount: ".concat(iterationCount, "` provided to `sequence.play()`\nis too high for a sequence with audio.\n\nTo fix this, either set `iterationCount` to a lower value, or remove the audio from the sequence."),
|
|
[
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/manual/audio",
|
|
title: "Using Audio"
|
|
},
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/api/core#sequence.attachaudio",
|
|
title: "Audio API"
|
|
}
|
|
]
|
|
);
|
|
iterationCount = 1e3;
|
|
}
|
|
if (iterationCount > 1) {
|
|
currentSource.loop = true;
|
|
currentSource.loopStart = range[0];
|
|
currentSource.loopEnd = range[1];
|
|
}
|
|
const initialTickerTime = ticker.time;
|
|
let initialElapsedPos = startPos - range[0];
|
|
const totalPlaybackLength = iterationLength * iterationCount;
|
|
currentSource.start(0, startPos, totalPlaybackLength - initialElapsedPos);
|
|
const tick = (currentTickerTime) => {
|
|
const elapsedTickerTime = Math.max(
|
|
currentTickerTime - initialTickerTime,
|
|
0
|
|
);
|
|
const elapsedTickerTimeInSeconds = elapsedTickerTime / 1e3;
|
|
const elapsedPos = Math.min(
|
|
elapsedTickerTimeInSeconds * rate + initialElapsedPos,
|
|
totalPlaybackLength
|
|
);
|
|
if (elapsedPos !== totalPlaybackLength) {
|
|
let currentIterationPos = elapsedPos / iterationLength % 1 * iterationLength;
|
|
this._updatePositionInState(currentIterationPos + range[0]);
|
|
requestNextTick();
|
|
} else {
|
|
this._updatePositionInState(range[1]);
|
|
this._playing = false;
|
|
cleanup();
|
|
deferred.resolve(true);
|
|
}
|
|
};
|
|
const cleanup = () => {
|
|
currentSource.stop();
|
|
currentSource.disconnect();
|
|
};
|
|
this._stopPlayCallback = () => {
|
|
cleanup();
|
|
ticker.offThisOrNextTick(tick);
|
|
ticker.offNextTick(tick);
|
|
if (this._playing)
|
|
deferred.resolve(false);
|
|
};
|
|
const requestNextTick = () => ticker.onNextTick(tick);
|
|
ticker.onThisOrNextTick(tick);
|
|
return deferred.promise;
|
|
}
|
|
};
|
|
|
|
// core/src/rafDrivers.ts
|
|
var import_dataverse9 = require("@theatre/dataverse");
|
|
var lastDriverId = 0;
|
|
function createRafDriver(conf) {
|
|
var _a;
|
|
const tick = (time) => {
|
|
ticker.tick(time);
|
|
};
|
|
const ticker = new import_dataverse9.Ticker({
|
|
onActive() {
|
|
var _a2;
|
|
(_a2 = conf == null ? void 0 : conf.start) == null ? void 0 : _a2.call(conf);
|
|
},
|
|
onDormant() {
|
|
var _a2;
|
|
(_a2 = conf == null ? void 0 : conf.stop) == null ? void 0 : _a2.call(conf);
|
|
}
|
|
});
|
|
const driverPublicApi = {
|
|
tick,
|
|
id: lastDriverId++,
|
|
name: (_a = conf == null ? void 0 : conf.name) != null ? _a : "CustomRafDriver-".concat(lastDriverId),
|
|
type: "Theatre_RafDriver_PublicAPI"
|
|
};
|
|
const driverPrivateApi = {
|
|
type: "Theatre_RafDriver_PrivateAPI",
|
|
publicApi: driverPublicApi,
|
|
ticker,
|
|
start: conf == null ? void 0 : conf.start,
|
|
stop: conf == null ? void 0 : conf.stop
|
|
};
|
|
setPrivateAPI(driverPublicApi, driverPrivateApi);
|
|
return driverPublicApi;
|
|
}
|
|
|
|
// core/src/coreTicker.ts
|
|
function createBasicRafDriver() {
|
|
let rafId = null;
|
|
const start = () => {
|
|
if (typeof window !== "undefined") {
|
|
const onAnimationFrame = (t2) => {
|
|
driver.tick(t2);
|
|
rafId = window.requestAnimationFrame(onAnimationFrame);
|
|
};
|
|
rafId = window.requestAnimationFrame(onAnimationFrame);
|
|
} else {
|
|
driver.tick(0);
|
|
setTimeout(() => driver.tick(1), 0);
|
|
}
|
|
};
|
|
const stop = () => {
|
|
if (typeof window !== "undefined") {
|
|
if (rafId !== null) {
|
|
window.cancelAnimationFrame(rafId);
|
|
}
|
|
} else {
|
|
}
|
|
};
|
|
const driver = createRafDriver({ name: "DefaultCoreRafDriver", start, stop });
|
|
return driver;
|
|
}
|
|
var coreRafDriver;
|
|
function getCoreRafDriver() {
|
|
if (!coreRafDriver) {
|
|
setCoreRafDriver(createBasicRafDriver());
|
|
}
|
|
return coreRafDriver;
|
|
}
|
|
function getCoreTicker() {
|
|
return getCoreRafDriver().ticker;
|
|
}
|
|
function setCoreRafDriver(driver) {
|
|
if (coreRafDriver) {
|
|
throw new Error("`setCoreRafDriver()` is already called.");
|
|
}
|
|
const driverPrivateApi = privateAPI(driver);
|
|
coreRafDriver = driverPrivateApi;
|
|
}
|
|
|
|
// core/src/sequences/TheatreSequence.ts
|
|
var TheatreSequence = class {
|
|
get type() {
|
|
return "Theatre_Sequence_PublicAPI";
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
constructor(sheet) {
|
|
setPrivateAPI(this, sheet);
|
|
}
|
|
play(conf) {
|
|
const priv = privateAPI(this);
|
|
if (priv._project.isReady()) {
|
|
const ticker = (conf == null ? void 0 : conf.rafDriver) ? privateAPI(conf.rafDriver).ticker : getCoreTicker();
|
|
return priv.play(conf != null ? conf : {}, ticker);
|
|
} else {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
notify.warning(
|
|
"Sequence can't be played",
|
|
"You seem to have called `sequence.play()` before the project has finished loading.\n\nThis would **not** a problem in production when using `@theatre/core`, since Theatre.js loads instantly in core mode. However, when using `@theatre/studio`, it takes a few milliseconds for it to load your project's state, before which your sequences cannot start playing.\n\nTo fix this, simply defer calling `sequence.play()` until after the project is loaded, like this:\n\n```\nproject.ready.then(() => {\n sequence.play()\n})\n```",
|
|
[
|
|
{
|
|
url: "https://www.theatrejs.com/docs/0.5/api/core#project.ready",
|
|
title: "Project.ready"
|
|
}
|
|
]
|
|
);
|
|
}
|
|
const d2 = defer();
|
|
d2.resolve(true);
|
|
return d2.promise;
|
|
}
|
|
}
|
|
pause() {
|
|
privateAPI(this).pause();
|
|
}
|
|
get position() {
|
|
return privateAPI(this).position;
|
|
}
|
|
set position(position) {
|
|
privateAPI(this).position = position;
|
|
}
|
|
__experimental_getKeyframes(prop) {
|
|
return privateAPI(this).getKeyframesOfSimpleProp(prop);
|
|
}
|
|
async attachAudio(args) {
|
|
const { audioContext, destinationNode, decodedBuffer, gainNode } = await resolveAudioBuffer(args);
|
|
const playbackController = new AudioPlaybackController(
|
|
decodedBuffer,
|
|
audioContext,
|
|
gainNode
|
|
);
|
|
privateAPI(this).replacePlaybackController(playbackController);
|
|
return { audioContext, destinationNode, decodedBuffer, gainNode };
|
|
}
|
|
get pointer() {
|
|
return privateAPI(this).pointer;
|
|
}
|
|
};
|
|
async function resolveAudioBuffer(args) {
|
|
function getAudioContext() {
|
|
if (args.audioContext)
|
|
return Promise.resolve(args.audioContext);
|
|
const ctx = new AudioContext();
|
|
if (ctx.state === "running")
|
|
return Promise.resolve(ctx);
|
|
if (typeof window === "undefined") {
|
|
return Promise.resolve(ctx);
|
|
}
|
|
return new Promise((resolve) => {
|
|
const listener = () => {
|
|
ctx.resume().catch((err) => {
|
|
console.error(err);
|
|
});
|
|
};
|
|
const eventsToHookInto = [
|
|
"mousedown",
|
|
"keydown",
|
|
"touchstart"
|
|
];
|
|
const eventListenerOpts = { capture: true, passive: false };
|
|
eventsToHookInto.forEach((eventName) => {
|
|
window.addEventListener(eventName, listener, eventListenerOpts);
|
|
});
|
|
ctx.addEventListener("statechange", () => {
|
|
if (ctx.state === "running") {
|
|
eventsToHookInto.forEach((eventName) => {
|
|
window.removeEventListener(eventName, listener, eventListenerOpts);
|
|
});
|
|
resolve(ctx);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
async function getAudioBuffer() {
|
|
if (args.source instanceof AudioBuffer) {
|
|
return args.source;
|
|
}
|
|
const decodedBufferDeferred = defer();
|
|
if (typeof args.source !== "string") {
|
|
throw new Error(
|
|
"Error validating arguments to sequence.attachAudio(). args.source must either be a string or an instance of AudioBuffer."
|
|
);
|
|
}
|
|
let fetchResponse;
|
|
try {
|
|
fetchResponse = await fetch(args.source);
|
|
} catch (e2) {
|
|
console.error(e2);
|
|
throw new Error(
|
|
"Could not fetch '".concat(args.source, "'. Network error logged above.")
|
|
);
|
|
}
|
|
let arrayBuffer;
|
|
try {
|
|
arrayBuffer = await fetchResponse.arrayBuffer();
|
|
} catch (e2) {
|
|
console.error(e2);
|
|
throw new Error("Could not read '".concat(args.source, "' as an arrayBuffer."));
|
|
}
|
|
const audioContext2 = await audioContextPromise;
|
|
audioContext2.decodeAudioData(
|
|
arrayBuffer,
|
|
decodedBufferDeferred.resolve,
|
|
decodedBufferDeferred.reject
|
|
);
|
|
let decodedBuffer2;
|
|
try {
|
|
decodedBuffer2 = await decodedBufferDeferred.promise;
|
|
} catch (e2) {
|
|
console.error(e2);
|
|
throw new Error("Could not decode ".concat(args.source, " as an audio file."));
|
|
}
|
|
return decodedBuffer2;
|
|
}
|
|
const audioContextPromise = getAudioContext();
|
|
const audioBufferPromise = getAudioBuffer();
|
|
const [audioContext, decodedBuffer] = await Promise.all([
|
|
audioContextPromise,
|
|
audioBufferPromise
|
|
]);
|
|
const destinationNode = args.destinationNode || audioContext.destination;
|
|
const gainNode = audioContext.createGain();
|
|
gainNode.connect(destinationNode);
|
|
return {
|
|
audioContext,
|
|
decodedBuffer,
|
|
gainNode,
|
|
destinationNode
|
|
};
|
|
}
|
|
|
|
// shared/src/instanceTypes.ts
|
|
var isProject = typeAsserter("Theatre_Project");
|
|
var isSheet = typeAsserter("Theatre_Sheet");
|
|
var isSheetTemplate = typeAsserter(
|
|
"Theatre_SheetTemplate"
|
|
);
|
|
var isSheetObject = typeAsserter("Theatre_SheetObject");
|
|
var isSequence = typeAsserter("Theatre_Sequence");
|
|
var isSheetObjectTemplate = typeAsserter(
|
|
"Theatre_SheetObjectTemplate"
|
|
);
|
|
var isProjectPublicAPI = typeAsserter(
|
|
"Theatre_Project_PublicAPI"
|
|
);
|
|
var isSheetPublicAPI = typeAsserter("Theatre_Sheet_PublicAPI");
|
|
var isSheetObjectPublicAPI = typeAsserter(
|
|
"Theatre_SheetObject_PublicAPI"
|
|
);
|
|
function typeAsserter(t2) {
|
|
return (v2) => typeof v2 === "object" && !!v2 && v2.type === t2;
|
|
}
|
|
|
|
// core/src/sequences/Sequence.ts
|
|
var possibleDirections = [
|
|
"normal",
|
|
"reverse",
|
|
"alternate",
|
|
"alternateReverse"
|
|
];
|
|
var Sequence = class {
|
|
constructor(_project, _sheet, _lengthD, _subUnitsPerUnitD, playbackController) {
|
|
this._project = _project;
|
|
this._sheet = _sheet;
|
|
this._lengthD = _lengthD;
|
|
this._subUnitsPerUnitD = _subUnitsPerUnitD;
|
|
__publicField(this, "address");
|
|
__publicField(this, "publicApi");
|
|
__publicField(this, "_playbackControllerBox");
|
|
__publicField(this, "_prismOfStatePointer");
|
|
__publicField(this, "_positionD");
|
|
__publicField(this, "_positionFormatterD");
|
|
__publicField(this, "_playableRangeD");
|
|
__publicField(this, "pointer", (0, import_dataverse12.pointer)({ root: this, path: [] }));
|
|
__publicField(this, "$$isPointerToPrismProvider", true);
|
|
__publicField(this, "_logger");
|
|
__publicField(this, "closestGridPosition", (posInUnitSpace) => {
|
|
const subUnitsPerUnit = this.subUnitsPerUnit;
|
|
const gridLength = 1 / subUnitsPerUnit;
|
|
return parseFloat(
|
|
(Math.round(posInUnitSpace / gridLength) * gridLength).toFixed(3)
|
|
);
|
|
});
|
|
this._logger = _project._logger.named("Sheet", _sheet.address.sheetId).named("Instance", _sheet.address.sheetInstanceId);
|
|
this.address = __spreadProps(__spreadValues({}, this._sheet.address), { sequenceName: "default" });
|
|
this.publicApi = new TheatreSequence(this);
|
|
this._playbackControllerBox = new import_dataverse11.Atom(
|
|
playbackController != null ? playbackController : new DefaultPlaybackController()
|
|
);
|
|
this._prismOfStatePointer = (0, import_dataverse13.prism)(
|
|
() => this._playbackControllerBox.prism.getValue().statePointer
|
|
);
|
|
this._positionD = (0, import_dataverse13.prism)(() => {
|
|
const statePointer = this._prismOfStatePointer.getValue();
|
|
return (0, import_dataverse13.val)(statePointer.position);
|
|
});
|
|
this._positionFormatterD = (0, import_dataverse13.prism)(() => {
|
|
const subUnitsPerUnit = (0, import_dataverse13.val)(this._subUnitsPerUnitD);
|
|
return new TimeBasedPositionFormatter(subUnitsPerUnit);
|
|
});
|
|
}
|
|
get type() {
|
|
return "Theatre_Sequence";
|
|
}
|
|
pointerToPrism(pointer3) {
|
|
const { path } = (0, import_dataverse10.getPointerParts)(pointer3);
|
|
if (path.length === 0) {
|
|
return (0, import_dataverse13.prism)(() => ({
|
|
length: (0, import_dataverse13.val)(this.pointer.length),
|
|
playing: (0, import_dataverse13.val)(this.pointer.playing),
|
|
position: (0, import_dataverse13.val)(this.pointer.position),
|
|
subUnitsPerUnit: (0, import_dataverse13.val)(this.pointer.subUnitsPerUnit)
|
|
}));
|
|
}
|
|
if (path.length > 1) {
|
|
return (0, import_dataverse13.prism)(() => void 0);
|
|
}
|
|
const [prop] = path;
|
|
if (prop === "length") {
|
|
return this._lengthD;
|
|
} else if (prop === "subUnitsPerUnit") {
|
|
return this._subUnitsPerUnitD;
|
|
} else if (prop === "position") {
|
|
return this._positionD;
|
|
} else if (prop === "playing") {
|
|
return (0, import_dataverse13.prism)(() => {
|
|
return (0, import_dataverse13.val)(this._prismOfStatePointer.getValue().playing);
|
|
});
|
|
} else {
|
|
return (0, import_dataverse13.prism)(() => void 0);
|
|
}
|
|
}
|
|
/**
|
|
* Takes a pointer to a property of a SheetObject and returns the keyframes of that property.
|
|
*
|
|
* Theoretically, this method can be called from inside a prism so it can be reactive.
|
|
*/
|
|
getKeyframesOfSimpleProp(prop) {
|
|
const { path, root: root2 } = (0, import_dataverse10.getPointerParts)(prop);
|
|
if (!isSheetObject(root2)) {
|
|
throw new InvalidArgumentError(
|
|
"Argument prop must be a pointer to a SheetObject property"
|
|
);
|
|
}
|
|
const trackP = (0, import_dataverse13.val)(
|
|
this._project.pointers.historic.sheetsById[this._sheet.address.sheetId].sequence.tracksByObject[root2.address.objectKey]
|
|
);
|
|
if (!trackP) {
|
|
return [];
|
|
}
|
|
const { trackData, trackIdByPropPath } = trackP;
|
|
const objectAddress = encodePathToProp(path);
|
|
const id = trackIdByPropPath[objectAddress];
|
|
if (!id) {
|
|
return [];
|
|
}
|
|
const track = trackData[id];
|
|
if (!track) {
|
|
return [];
|
|
}
|
|
return track.keyframes;
|
|
}
|
|
get positionFormatter() {
|
|
return this._positionFormatterD.getValue();
|
|
}
|
|
get prismOfStatePointer() {
|
|
return this._prismOfStatePointer;
|
|
}
|
|
get length() {
|
|
return this._lengthD.getValue();
|
|
}
|
|
get positionPrism() {
|
|
return this._positionD;
|
|
}
|
|
get position() {
|
|
return this._playbackControllerBox.get().getCurrentPosition();
|
|
}
|
|
get subUnitsPerUnit() {
|
|
return this._subUnitsPerUnitD.getValue();
|
|
}
|
|
get positionSnappedToGrid() {
|
|
return this.closestGridPosition(this.position);
|
|
}
|
|
set position(requestedPosition) {
|
|
let position = requestedPosition;
|
|
this.pause();
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (typeof position !== "number") {
|
|
console.error(
|
|
"value t in sequence.position = t must be a number. ".concat(typeof position, " given")
|
|
);
|
|
position = 0;
|
|
}
|
|
if (position < 0) {
|
|
console.error(
|
|
"sequence.position must be a positive number. ".concat(position, " given")
|
|
);
|
|
position = 0;
|
|
}
|
|
}
|
|
if (position > this.length) {
|
|
position = this.length;
|
|
}
|
|
const dur = this.length;
|
|
this._playbackControllerBox.get().gotoPosition(position > dur ? dur : position);
|
|
}
|
|
getDurationCold() {
|
|
return this._lengthD.getValue();
|
|
}
|
|
get playing() {
|
|
return (0, import_dataverse13.val)(this._playbackControllerBox.get().statePointer.playing);
|
|
}
|
|
_makeRangeFromSequenceTemplate() {
|
|
return (0, import_dataverse13.prism)(() => {
|
|
return [0, (0, import_dataverse13.val)(this._lengthD)];
|
|
});
|
|
}
|
|
/**
|
|
* Controls the playback within a range. Repeats infinitely unless stopped.
|
|
*
|
|
* @remarks
|
|
* One use case for this is to play the playback within the focus range.
|
|
*
|
|
* @param rangeD - The prism that contains the range that will be used for the playback
|
|
*
|
|
* @returns a promise that gets rejected if the playback stopped for whatever reason
|
|
*
|
|
*/
|
|
playDynamicRange(rangeD, ticker) {
|
|
return this._playbackControllerBox.get().playDynamicRange(rangeD, ticker);
|
|
}
|
|
async play(conf, ticker) {
|
|
const sequenceDuration = this.length;
|
|
const range = conf && conf.range ? conf.range : [0, sequenceDuration];
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (typeof range[0] !== "number" || range[0] < 0) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.range[0] in sequence.play(conf) must be a positive number. ".concat(JSON.stringify(
|
|
range[0]
|
|
), " given.")
|
|
);
|
|
}
|
|
if (range[0] >= sequenceDuration) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.range[0] in sequence.play(conf) cannot be longer than the duration of the sequence, which is ".concat(sequenceDuration, "s. ").concat(JSON.stringify(
|
|
range[0]
|
|
), " given.")
|
|
);
|
|
}
|
|
if (typeof range[1] !== "number" || range[1] <= 0) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.range[1] in sequence.play(conf) must be a number larger than zero. ".concat(JSON.stringify(
|
|
range[1]
|
|
), " given.")
|
|
);
|
|
}
|
|
if (range[1] > sequenceDuration) {
|
|
notify.warning(
|
|
"Couldn't play sequence in given range",
|
|
"Your animation will still play until the end of the sequence, however the argument `conf.range[1]` given in `sequence.play(conf)` (".concat(JSON.stringify(
|
|
range[1]
|
|
), "s) is longer than the duration of the sequence (").concat(sequenceDuration, "s).\n\nTo fix this, either set `conf.range[1]` to be less the duration of the sequence, or adjust the sequence duration in the UI."),
|
|
[
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/manual/sequences",
|
|
title: "Sequences"
|
|
},
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/manual/sequences",
|
|
title: "Playback API"
|
|
}
|
|
]
|
|
);
|
|
range[1] = sequenceDuration;
|
|
}
|
|
if (range[1] <= range[0]) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.range[1] in sequence.play(conf) must be larger than conf.range[0]. ".concat(JSON.stringify(
|
|
range
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
const iterationCount = conf && typeof conf.iterationCount === "number" ? conf.iterationCount : 1;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (!(Number.isInteger(iterationCount) && iterationCount > 0) && iterationCount !== Infinity) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.iterationCount in sequence.play(conf) must be an integer larger than 0. ".concat(JSON.stringify(
|
|
iterationCount
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
const rate = conf && typeof conf.rate !== "undefined" ? conf.rate : 1;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (typeof rate !== "number" || rate === 0) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.rate in sequence.play(conf) must be a number larger than 0. ".concat(JSON.stringify(
|
|
rate
|
|
), " given.")
|
|
);
|
|
}
|
|
if (rate < 0) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.rate in sequence.play(conf) must be a number larger than 0. ".concat(JSON.stringify(
|
|
rate
|
|
), " given. If you want the animation to play backwards, try setting conf.direction to 'reverse' or 'alternateReverse'.")
|
|
);
|
|
}
|
|
}
|
|
const direction = conf && conf.direction ? conf.direction : "normal";
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (possibleDirections.indexOf(direction) === -1) {
|
|
throw new InvalidArgumentError(
|
|
"Argument conf.direction in sequence.play(conf) must be one of ".concat(JSON.stringify(
|
|
possibleDirections
|
|
), ". ").concat(JSON.stringify(direction), " given. ").concat(didYouMean(
|
|
direction,
|
|
possibleDirections
|
|
))
|
|
);
|
|
}
|
|
}
|
|
return await this._play(
|
|
iterationCount,
|
|
[range[0], range[1]],
|
|
rate,
|
|
direction,
|
|
ticker
|
|
);
|
|
}
|
|
_play(iterationCount, range, rate, direction, ticker) {
|
|
return this._playbackControllerBox.get().play(iterationCount, range, rate, direction, ticker);
|
|
}
|
|
pause() {
|
|
this._playbackControllerBox.get().pause();
|
|
}
|
|
replacePlaybackController(playbackController) {
|
|
this.pause();
|
|
const oldController = this._playbackControllerBox.get();
|
|
this._playbackControllerBox.set(playbackController);
|
|
const time = oldController.getCurrentPosition();
|
|
oldController.destroy();
|
|
playbackController.gotoPosition(time);
|
|
}
|
|
};
|
|
var TimeBasedPositionFormatter = class {
|
|
constructor(_fps) {
|
|
this._fps = _fps;
|
|
}
|
|
formatSubUnitForGrid(posInUnitSpace) {
|
|
const subSecondPos = posInUnitSpace % 1;
|
|
const frame = 1 / this._fps;
|
|
const frames = Math.round(subSecondPos / frame);
|
|
return frames + "f";
|
|
}
|
|
formatFullUnitForGrid(posInUnitSpace) {
|
|
let p2 = posInUnitSpace;
|
|
let s2 = "";
|
|
if (p2 >= hour) {
|
|
const hours = Math.floor(p2 / hour);
|
|
s2 += hours + "h";
|
|
p2 = p2 % hour;
|
|
}
|
|
if (p2 >= minute) {
|
|
const minutes = Math.floor(p2 / minute);
|
|
s2 += minutes + "m";
|
|
p2 = p2 % minute;
|
|
}
|
|
if (p2 >= second) {
|
|
const seconds = Math.floor(p2 / second);
|
|
s2 += seconds + "s";
|
|
p2 = p2 % second;
|
|
}
|
|
const frame = 1 / this._fps;
|
|
if (p2 >= frame) {
|
|
const frames = Math.floor(p2 / frame);
|
|
s2 += frames + "f";
|
|
p2 = p2 % frame;
|
|
}
|
|
return s2.length === 0 ? "0s" : s2;
|
|
}
|
|
formatForPlayhead(posInUnitSpace) {
|
|
let p2 = posInUnitSpace;
|
|
let s2 = "";
|
|
if (p2 >= hour) {
|
|
const hours = Math.floor(p2 / hour);
|
|
s2 += padStart_default(hours.toString(), 2, "0") + "h";
|
|
p2 = p2 % hour;
|
|
}
|
|
if (p2 >= minute) {
|
|
const minutes = Math.floor(p2 / minute);
|
|
s2 += padStart_default(minutes.toString(), 2, "0") + "m";
|
|
p2 = p2 % minute;
|
|
} else if (s2.length > 0) {
|
|
s2 += "00m";
|
|
}
|
|
if (p2 >= second) {
|
|
const seconds = Math.floor(p2 / second);
|
|
s2 += padStart_default(seconds.toString(), 2, "0") + "s";
|
|
p2 = p2 % second;
|
|
} else {
|
|
s2 += "00s";
|
|
}
|
|
const frameLength = 1 / this._fps;
|
|
if (p2 >= frameLength) {
|
|
const frames = Math.round(p2 / frameLength);
|
|
s2 += padStart_default(frames.toString(), 2, "0") + "f";
|
|
p2 = p2 % frameLength;
|
|
} else if (p2 / frameLength > 0.98) {
|
|
const frames = 1;
|
|
s2 += padStart_default(frames.toString(), 2, "0") + "f";
|
|
p2 = p2 % frameLength;
|
|
} else {
|
|
s2 += "00f";
|
|
}
|
|
return s2.length === 0 ? "00s00f" : s2;
|
|
}
|
|
formatBasic(posInUnitSpace) {
|
|
return posInUnitSpace.toFixed(2) + "s";
|
|
}
|
|
};
|
|
var second = 1;
|
|
var minute = second * 60;
|
|
var hour = minute * 60;
|
|
|
|
// core/src/propTypes/index.ts
|
|
var propTypes_exports = {};
|
|
__export(propTypes_exports, {
|
|
boolean: () => boolean,
|
|
compound: () => compound,
|
|
file: () => file,
|
|
image: () => image,
|
|
number: () => number,
|
|
rgba: () => rgba,
|
|
string: () => string,
|
|
stringLiteral: () => stringLiteral
|
|
});
|
|
|
|
// shared/src/utils/ellipsify.ts
|
|
function ellipsify(str, maxLength) {
|
|
if (str.length <= maxLength)
|
|
return str;
|
|
return str.substr(0, maxLength - 3) + "...";
|
|
}
|
|
|
|
// shared/src/utils/userReadableTypeOfValue.ts
|
|
var userReadableTypeOfValue = (v2) => {
|
|
if (typeof v2 === "string") {
|
|
return 'string("'.concat(ellipsify(v2, 10), '")');
|
|
} else if (typeof v2 === "number") {
|
|
return "number(".concat(ellipsify(String(v2), 10), ")");
|
|
} else if (v2 === null) {
|
|
return "null";
|
|
} else if (v2 === void 0) {
|
|
return "undefined";
|
|
} else if (typeof v2 === "boolean") {
|
|
return String(v2);
|
|
} else if (Array.isArray(v2)) {
|
|
return "array";
|
|
} else if (typeof v2 === "object") {
|
|
return "object";
|
|
} else {
|
|
return "unknown";
|
|
}
|
|
};
|
|
var userReadableTypeOfValue_default = userReadableTypeOfValue;
|
|
|
|
// shared/src/utils/color.ts
|
|
function rgba2hex(rgba2, {
|
|
/** Alpha is usually an optional value for most hex inputs, so if it's opaque, we can omit its value. */
|
|
removeAlphaIfOpaque = false
|
|
} = {}) {
|
|
const alpha = (rgba2.a * 255 | 1 << 8).toString(16).slice(1);
|
|
const hex = (rgba2.r * 255 | 1 << 8).toString(16).slice(1) + (rgba2.g * 255 | 1 << 8).toString(16).slice(1) + (rgba2.b * 255 | 1 << 8).toString(16).slice(1) + (removeAlphaIfOpaque && alpha === "ff" ? "" : alpha);
|
|
return "#".concat(hex);
|
|
}
|
|
function decorateRgba(rgba2) {
|
|
return __spreadProps(__spreadValues({}, rgba2), {
|
|
toString() {
|
|
return rgba2hex(this, { removeAlphaIfOpaque: true });
|
|
}
|
|
});
|
|
}
|
|
function clampRgba(rgba2) {
|
|
return Object.fromEntries(
|
|
Object.entries(rgba2).map(([key, value]) => [key, clamp_default(value, 0, 1)])
|
|
);
|
|
}
|
|
function linearSrgbToSrgb(rgba2) {
|
|
function compress(x2) {
|
|
if (x2 >= 31308e-7)
|
|
return 1.055 * x2 ** (1 / 2.4) - 0.055;
|
|
else
|
|
return 12.92 * x2;
|
|
}
|
|
return clampRgba({
|
|
r: compress(rgba2.r),
|
|
g: compress(rgba2.g),
|
|
b: compress(rgba2.b),
|
|
a: rgba2.a
|
|
});
|
|
}
|
|
function srgbToLinearSrgb(rgba2) {
|
|
function expand(x2) {
|
|
if (x2 >= 0.04045)
|
|
return ((x2 + 0.055) / (1 + 0.055)) ** 2.4;
|
|
else
|
|
return x2 / 12.92;
|
|
}
|
|
return {
|
|
r: expand(rgba2.r),
|
|
g: expand(rgba2.g),
|
|
b: expand(rgba2.b),
|
|
a: rgba2.a
|
|
};
|
|
}
|
|
function linearSrgbToOklab(rgba2) {
|
|
let l2 = 0.4122214708 * rgba2.r + 0.5363325363 * rgba2.g + 0.0514459929 * rgba2.b;
|
|
let m = 0.2119034982 * rgba2.r + 0.6806995451 * rgba2.g + 0.1073969566 * rgba2.b;
|
|
let s2 = 0.0883024619 * rgba2.r + 0.2817188376 * rgba2.g + 0.6299787005 * rgba2.b;
|
|
let l_ = Math.cbrt(l2);
|
|
let m_ = Math.cbrt(m);
|
|
let s_ = Math.cbrt(s2);
|
|
return {
|
|
L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
|
|
a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
|
|
b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_,
|
|
alpha: rgba2.a
|
|
};
|
|
}
|
|
function oklabToLinearSrgb(laba) {
|
|
let l_ = laba.L + 0.3963377774 * laba.a + 0.2158037573 * laba.b;
|
|
let m_ = laba.L - 0.1055613458 * laba.a - 0.0638541728 * laba.b;
|
|
let s_ = laba.L - 0.0894841775 * laba.a - 1.291485548 * laba.b;
|
|
let l2 = l_ * l_ * l_;
|
|
let m = m_ * m_ * m_;
|
|
let s2 = s_ * s_ * s_;
|
|
return {
|
|
r: 4.0767416621 * l2 - 3.3077115913 * m + 0.2309699292 * s2,
|
|
g: -1.2684380046 * l2 + 2.6097574011 * m - 0.3413193965 * s2,
|
|
b: -0.0041960863 * l2 - 0.7034186147 * m + 1.707614701 * s2,
|
|
a: laba.alpha
|
|
};
|
|
}
|
|
|
|
// core/src/propTypes/internals.ts
|
|
var propTypeSymbol = Symbol("TheatrePropType_Basic");
|
|
function isLonghandPropType(t2) {
|
|
return typeof t2 === "object" && !!t2 && t2[propTypeSymbol] === "TheatrePropType";
|
|
}
|
|
function toLonghandProp(p2) {
|
|
if (typeof p2 === "number") {
|
|
return number(p2);
|
|
} else if (typeof p2 === "boolean") {
|
|
return boolean(p2);
|
|
} else if (typeof p2 === "string") {
|
|
return string(p2);
|
|
} else if (typeof p2 === "object" && !!p2) {
|
|
if (isLonghandPropType(p2))
|
|
return p2;
|
|
if (isPlainObject_default(p2)) {
|
|
return compound(p2);
|
|
} else {
|
|
throw new InvalidArgumentError(
|
|
"This value is not a valid prop type: ".concat(userReadableTypeOfValue_default(p2))
|
|
);
|
|
}
|
|
} else {
|
|
throw new InvalidArgumentError(
|
|
"This value is not a valid prop type: ".concat(userReadableTypeOfValue_default(p2))
|
|
);
|
|
}
|
|
}
|
|
function sanitizeCompoundProps(props) {
|
|
const sanitizedProps = {};
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (typeof props !== "object" || !props) {
|
|
throw new InvalidArgumentError(
|
|
"t.compound() expects an object, like: {x: 10}. ".concat(userReadableTypeOfValue_default(
|
|
props
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
for (const key of Object.keys(props)) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (typeof key !== "string") {
|
|
throw new InvalidArgumentError(
|
|
"t.compound()'s keys must be all strings. ".concat(userReadableTypeOfValue_default(
|
|
key
|
|
), " given.")
|
|
);
|
|
} else if (key.length === 0 || !key.match(/^\w+$/)) {
|
|
throw new InvalidArgumentError(
|
|
"compound key ".concat(userReadableTypeOfValue_default(
|
|
key
|
|
), " is invalid. The keys must be alphanumeric and start with a letter.")
|
|
);
|
|
} else if (key.length > 64) {
|
|
throw new InvalidArgumentError(
|
|
"compound key ".concat(userReadableTypeOfValue_default(key), " is too long.")
|
|
);
|
|
}
|
|
}
|
|
const val8 = props[key];
|
|
if (isLonghandPropType(val8)) {
|
|
sanitizedProps[key] = val8;
|
|
} else {
|
|
sanitizedProps[key] = toLonghandProp(val8);
|
|
}
|
|
}
|
|
return sanitizedProps;
|
|
}
|
|
|
|
// core/src/propTypes/index.ts
|
|
var validateCommonOpts = (fnCallSignature, opts) => {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (opts === void 0)
|
|
return;
|
|
if (typeof opts !== "object" || opts === null) {
|
|
throw new Error(
|
|
"opts in ".concat(fnCallSignature, " must either be undefined or an object.")
|
|
);
|
|
}
|
|
if (Object.prototype.hasOwnProperty.call(opts, "label")) {
|
|
const { label } = opts;
|
|
if (typeof label !== "string") {
|
|
throw new Error(
|
|
"opts.label in ".concat(fnCallSignature, " should be a string. ").concat(userReadableTypeOfValue_default(
|
|
label
|
|
), " given.")
|
|
);
|
|
}
|
|
if (label.trim().length !== label.length) {
|
|
throw new Error(
|
|
"opts.label in ".concat(fnCallSignature, ' should not start/end with whitespace. "').concat(label, '" given.')
|
|
);
|
|
}
|
|
if (label.length === 0) {
|
|
throw new Error(
|
|
"opts.label in ".concat(fnCallSignature, " should not be an empty string. If you wish to have no label, remove opts.label from opts.")
|
|
);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var compound = (props, opts = {}) => {
|
|
validateCommonOpts("t.compound(props, opts)", opts);
|
|
const sanitizedProps = sanitizeCompoundProps(props);
|
|
const deserializationCache = /* @__PURE__ */ new WeakMap();
|
|
const config = {
|
|
type: "compound",
|
|
props: sanitizedProps,
|
|
valueType: null,
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
default: mapValues_default(sanitizedProps, (p2) => p2.default),
|
|
deserializeAndSanitize: (json) => {
|
|
if (typeof json !== "object" || !json)
|
|
return void 0;
|
|
if (deserializationCache.has(json)) {
|
|
return deserializationCache.get(json);
|
|
}
|
|
const deserialized = {};
|
|
let atLeastOnePropWasDeserialized = false;
|
|
for (const [key, propConfig] of Object.entries(sanitizedProps)) {
|
|
if (Object.prototype.hasOwnProperty.call(json, key)) {
|
|
const deserializedSub = propConfig.deserializeAndSanitize(
|
|
json[key]
|
|
);
|
|
if (deserializedSub != null) {
|
|
atLeastOnePropWasDeserialized = true;
|
|
deserialized[key] = deserializedSub;
|
|
}
|
|
}
|
|
}
|
|
deserializationCache.set(json, deserialized);
|
|
if (atLeastOnePropWasDeserialized) {
|
|
return deserialized;
|
|
}
|
|
}
|
|
};
|
|
return config;
|
|
};
|
|
var file = (defaultValue, opts = {}) => {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.file(defaultValue, opts)", opts);
|
|
}
|
|
const interpolate = (left, right, progression) => {
|
|
var _a;
|
|
const stringInterpolate = (_a = opts.interpolate) != null ? _a : leftInterpolate;
|
|
return {
|
|
type: "file",
|
|
id: stringInterpolate(left.id, right.id, progression)
|
|
};
|
|
};
|
|
return {
|
|
type: "file",
|
|
default: { type: "file", id: defaultValue },
|
|
valueType: null,
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
interpolate,
|
|
deserializeAndSanitize: _ensureFile
|
|
};
|
|
};
|
|
var _ensureFile = (val8) => {
|
|
if (!val8)
|
|
return void 0;
|
|
let valid = true;
|
|
if (typeof val8.id !== "string" && ![null, void 0].includes(val8.id)) {
|
|
valid = false;
|
|
}
|
|
if (val8.type !== "file")
|
|
valid = false;
|
|
if (!valid)
|
|
return void 0;
|
|
return val8;
|
|
};
|
|
var image = (defaultValue, opts = {}) => {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.image(defaultValue, opts)", opts);
|
|
}
|
|
const interpolate = (left, right, progression) => {
|
|
var _a;
|
|
const stringInterpolate = (_a = opts.interpolate) != null ? _a : leftInterpolate;
|
|
return {
|
|
type: "image",
|
|
id: stringInterpolate(left.id, right.id, progression)
|
|
};
|
|
};
|
|
return {
|
|
type: "image",
|
|
default: { type: "image", id: defaultValue },
|
|
valueType: null,
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
interpolate,
|
|
deserializeAndSanitize: _ensureImage
|
|
};
|
|
};
|
|
var _ensureImage = (val8) => {
|
|
if (!val8)
|
|
return void 0;
|
|
let valid = true;
|
|
if (typeof val8.id !== "string" && ![null, void 0].includes(val8.id)) {
|
|
valid = false;
|
|
}
|
|
if (val8.type !== "image")
|
|
valid = false;
|
|
if (!valid)
|
|
return void 0;
|
|
return val8;
|
|
};
|
|
var number = (defaultValue, opts = {}) => {
|
|
var _a;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.number(defaultValue, opts)", opts);
|
|
if (typeof defaultValue !== "number" || !isFinite(defaultValue)) {
|
|
throw new Error(
|
|
"Argument defaultValue in t.number(defaultValue) must be a number. ".concat(userReadableTypeOfValue_default(
|
|
defaultValue
|
|
), " given.")
|
|
);
|
|
}
|
|
if (typeof opts === "object" && opts !== null) {
|
|
if (Object.prototype.hasOwnProperty.call(opts, "range")) {
|
|
if (!Array.isArray(opts.range)) {
|
|
throw new Error(
|
|
"opts.range in t.number(defaultValue, opts) must be a tuple of two numbers. ".concat(userReadableTypeOfValue_default(
|
|
opts.range
|
|
), " given.")
|
|
);
|
|
}
|
|
if (opts.range.length !== 2) {
|
|
throw new Error(
|
|
"opts.range in t.number(defaultValue, opts) must have two elements. ".concat(opts.range.length, " given.")
|
|
);
|
|
}
|
|
if (!opts.range.every((n2) => typeof n2 === "number" && !isNaN(n2))) {
|
|
throw new Error(
|
|
"opts.range in t.number(defaultValue, opts) must be a tuple of two numbers."
|
|
);
|
|
}
|
|
if (opts.range[0] >= opts.range[1]) {
|
|
throw new Error(
|
|
"opts.range[0] in t.number(defaultValue, opts) must be smaller than opts.range[1]. Given: ".concat(JSON.stringify(
|
|
opts.range
|
|
))
|
|
);
|
|
}
|
|
}
|
|
if (Object.prototype.hasOwnProperty.call(opts, "nudgeMultiplier")) {
|
|
if (typeof opts.nudgeMultiplier !== "number" || !isFinite(opts.nudgeMultiplier)) {
|
|
throw new Error(
|
|
"opts.nudgeMultiplier in t.number(defaultValue, opts) must be a finite number. ".concat(userReadableTypeOfValue_default(
|
|
opts.nudgeMultiplier
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
if (Object.prototype.hasOwnProperty.call(opts, "nudgeFn")) {
|
|
if (typeof opts.nudgeFn !== "function") {
|
|
throw new Error(
|
|
"opts.nudgeFn in t.number(defaultValue, opts) must be a function. ".concat(userReadableTypeOfValue_default(
|
|
opts.nudgeFn
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return __spreadProps(__spreadValues({
|
|
type: "number",
|
|
valueType: 0,
|
|
default: defaultValue,
|
|
[propTypeSymbol]: "TheatrePropType"
|
|
}, opts ? opts : {}), {
|
|
label: opts.label,
|
|
nudgeFn: (_a = opts.nudgeFn) != null ? _a : defaultNumberNudgeFn,
|
|
nudgeMultiplier: typeof opts.nudgeMultiplier === "number" ? opts.nudgeMultiplier : void 0,
|
|
interpolate: _interpolateNumber,
|
|
deserializeAndSanitize: numberDeserializer(opts.range)
|
|
});
|
|
};
|
|
var numberDeserializer = (range) => range ? (json) => {
|
|
if (!(typeof json === "number" && isFinite(json)))
|
|
return void 0;
|
|
return clamp_default(json, range[0], range[1]);
|
|
} : _ensureNumber;
|
|
var _ensureNumber = (value) => typeof value === "number" && isFinite(value) ? value : void 0;
|
|
var _interpolateNumber = (left, right, progression) => {
|
|
return left + progression * (right - left);
|
|
};
|
|
var rgba = (defaultValue = { r: 0, g: 0, b: 0, a: 1 }, opts = {}) => {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.rgba(defaultValue, opts)", opts);
|
|
let valid = true;
|
|
for (const p2 of ["r", "g", "b", "a"]) {
|
|
if (!Object.prototype.hasOwnProperty.call(defaultValue, p2) || typeof defaultValue[p2] !== "number") {
|
|
valid = false;
|
|
}
|
|
}
|
|
if (!valid) {
|
|
throw new Error(
|
|
"Argument defaultValue in t.rgba(defaultValue) must be of the shape { r: number; g: number, b: number, a: number; }."
|
|
);
|
|
}
|
|
}
|
|
const sanitized = {};
|
|
for (const component of ["r", "g", "b", "a"]) {
|
|
;
|
|
sanitized[component] = Math.min(
|
|
Math.max(defaultValue[component], 0),
|
|
1
|
|
);
|
|
}
|
|
return {
|
|
type: "rgba",
|
|
valueType: null,
|
|
default: decorateRgba(sanitized),
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
interpolate: _interpolateRgba,
|
|
deserializeAndSanitize: _sanitizeRgba
|
|
};
|
|
};
|
|
var _sanitizeRgba = (val8) => {
|
|
if (!val8)
|
|
return void 0;
|
|
let valid = true;
|
|
for (const c2 of ["r", "g", "b", "a"]) {
|
|
if (!Object.prototype.hasOwnProperty.call(val8, c2) || typeof val8[c2] !== "number") {
|
|
valid = false;
|
|
}
|
|
}
|
|
if (!valid)
|
|
return void 0;
|
|
const sanitized = {};
|
|
for (const c2 of ["r", "g", "b", "a"]) {
|
|
;
|
|
sanitized[c2] = Math.min(
|
|
Math.max(val8[c2], 0),
|
|
1
|
|
);
|
|
}
|
|
return decorateRgba(sanitized);
|
|
};
|
|
var _interpolateRgba = (left, right, progression) => {
|
|
const leftLab = linearSrgbToOklab(srgbToLinearSrgb(left));
|
|
const rightLab = linearSrgbToOklab(srgbToLinearSrgb(right));
|
|
const interpolatedLab = {
|
|
L: (1 - progression) * leftLab.L + progression * rightLab.L,
|
|
a: (1 - progression) * leftLab.a + progression * rightLab.a,
|
|
b: (1 - progression) * leftLab.b + progression * rightLab.b,
|
|
alpha: (1 - progression) * leftLab.alpha + progression * rightLab.alpha
|
|
};
|
|
const interpolatedRgba = linearSrgbToSrgb(oklabToLinearSrgb(interpolatedLab));
|
|
return decorateRgba(interpolatedRgba);
|
|
};
|
|
var boolean = (defaultValue, opts = {}) => {
|
|
var _a;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.boolean(defaultValue, opts)", opts);
|
|
if (typeof defaultValue !== "boolean") {
|
|
throw new Error(
|
|
"defaultValue in t.boolean(defaultValue) must be a boolean. ".concat(userReadableTypeOfValue_default(
|
|
defaultValue
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
return {
|
|
type: "boolean",
|
|
default: defaultValue,
|
|
valueType: null,
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
interpolate: (_a = opts.interpolate) != null ? _a : leftInterpolate,
|
|
deserializeAndSanitize: _ensureBoolean
|
|
};
|
|
};
|
|
var _ensureBoolean = (val8) => {
|
|
return typeof val8 === "boolean" ? val8 : void 0;
|
|
};
|
|
function leftInterpolate(left) {
|
|
return left;
|
|
}
|
|
var string = (defaultValue, opts = {}) => {
|
|
var _a;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateCommonOpts("t.string(defaultValue, opts)", opts);
|
|
if (typeof defaultValue !== "string") {
|
|
throw new Error(
|
|
"defaultValue in t.string(defaultValue) must be a string. ".concat(userReadableTypeOfValue_default(
|
|
defaultValue
|
|
), " given.")
|
|
);
|
|
}
|
|
}
|
|
return {
|
|
type: "string",
|
|
default: defaultValue,
|
|
valueType: null,
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
label: opts.label,
|
|
interpolate: (_a = opts.interpolate) != null ? _a : leftInterpolate,
|
|
deserializeAndSanitize: _ensureString
|
|
};
|
|
};
|
|
function _ensureString(s2) {
|
|
return typeof s2 === "string" ? s2 : void 0;
|
|
}
|
|
function stringLiteral(defaultValue, valuesAndLabels, opts = {}) {
|
|
var _a, _b;
|
|
return {
|
|
type: "stringLiteral",
|
|
default: defaultValue,
|
|
valuesAndLabels: __spreadValues({}, valuesAndLabels),
|
|
[propTypeSymbol]: "TheatrePropType",
|
|
valueType: null,
|
|
as: (_a = opts.as) != null ? _a : "menu",
|
|
label: opts.label,
|
|
interpolate: (_b = opts.interpolate) != null ? _b : leftInterpolate,
|
|
deserializeAndSanitize(json) {
|
|
if (typeof json !== "string")
|
|
return void 0;
|
|
if (Object.prototype.hasOwnProperty.call(valuesAndLabels, json)) {
|
|
return json;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var defaultNumberNudgeFn = ({
|
|
config,
|
|
deltaX,
|
|
deltaFraction,
|
|
magnitude
|
|
}) => {
|
|
var _a;
|
|
const { range } = config;
|
|
if (!config.nudgeMultiplier && range && !range.includes(Infinity) && !range.includes(-Infinity)) {
|
|
return deltaFraction * (range[1] - range[0]) * magnitude;
|
|
}
|
|
return deltaX * magnitude * ((_a = config.nudgeMultiplier) != null ? _a : 1);
|
|
};
|
|
|
|
// shared/src/utils/slashedPaths.ts
|
|
var normalizeSlashedPath = (p2) => p2.replace(/^[\s\/]*/, "").replace(/[\s\/]*$/, "").replace(/\s*\/\s*/g, " / ");
|
|
var getValidationErrorsOfSlashedPath = (p2) => {
|
|
if (typeof p2 !== "string")
|
|
return "it is not a string. (it is a ".concat(typeof p2, ")");
|
|
const components = p2.split(/\//);
|
|
if (components.length === 0)
|
|
return "it is empty.";
|
|
for (let i2 = 0; i2 < components.length; i2++) {
|
|
const component = components[i2].trim();
|
|
if (component.length === 0)
|
|
return "the component #".concat(i2 + 1, " is empty.");
|
|
if (component.length > 64)
|
|
return "the component '".concat(component, "' must have 64 characters or less.");
|
|
}
|
|
};
|
|
function validateAndSanitiseSlashedPathOrThrow(unsanitisedPath, fnName) {
|
|
const sanitisedPath = normalizeSlashedPath(unsanitisedPath);
|
|
if (process.env.NODE_ENV !== "development") {
|
|
return sanitisedPath;
|
|
}
|
|
const validation = getValidationErrorsOfSlashedPath(sanitisedPath);
|
|
if (validation) {
|
|
throw new InvalidArgumentError(
|
|
"The path in ".concat(fnName, "(").concat(typeof unsanitisedPath === "string" ? '"'.concat(unsanitisedPath, '"') : "", ") is invalid because ").concat(validation)
|
|
);
|
|
}
|
|
if (unsanitisedPath !== sanitisedPath) {
|
|
notify.warning(
|
|
"Invalid path provided to object",
|
|
"The path in `".concat(fnName, '("').concat(unsanitisedPath, '")` was sanitized to `"').concat(sanitisedPath, '"`.\n\n') + "Please replace the path with the sanitized one, otherwise it will likely break in the future.",
|
|
[
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/manual/objects#creating-sheet-objects",
|
|
title: "Sheet Objects"
|
|
},
|
|
{
|
|
url: "https://www.theatrejs.com/docs/latest/api/core#sheet.object",
|
|
title: "API"
|
|
}
|
|
]
|
|
);
|
|
}
|
|
return sanitisedPath;
|
|
}
|
|
|
|
// core/src/sheets/TheatreSheet.ts
|
|
var import_fast_deep_equal = __toESM(require_fast_deep_equal());
|
|
var weakMapOfUnsanitizedProps = /* @__PURE__ */ new WeakMap();
|
|
var TheatreSheet = class {
|
|
get type() {
|
|
return "Theatre_Sheet_PublicAPI";
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
constructor(sheet) {
|
|
setPrivateAPI(this, sheet);
|
|
}
|
|
object(key, config, opts) {
|
|
const internal2 = privateAPI(this);
|
|
const sanitizedPath = validateAndSanitiseSlashedPathOrThrow(
|
|
key,
|
|
"sheet.object"
|
|
);
|
|
const existingObject = internal2.getObject(sanitizedPath);
|
|
const nativeObject = null;
|
|
const actions = opts == null ? void 0 : opts.__actions__THIS_API_IS_UNSTABLE_AND_WILL_CHANGE_IN_THE_NEXT_VERSION;
|
|
if (existingObject) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
const prevConfig = weakMapOfUnsanitizedProps.get(existingObject);
|
|
if (prevConfig) {
|
|
if (!(0, import_fast_deep_equal.default)(config, prevConfig)) {
|
|
if ((opts == null ? void 0 : opts.reconfigure) === true) {
|
|
const sanitizedConfig = compound(config);
|
|
existingObject.template.reconfigure(sanitizedConfig);
|
|
weakMapOfUnsanitizedProps.set(existingObject, config);
|
|
return existingObject.publicApi;
|
|
} else {
|
|
throw new Error(
|
|
'You seem to have called sheet.object("'.concat(key, '", config) twice, with different values for `config`. ') + "This is disallowed because changing the config of an object on the fly would make it difficult to reason about.\n\n" + 'You can fix this by either re-using the existing object, or calling sheet.object("'.concat(key, '", config) with the same config.\n\n') + "If you mean to reconfigure the object's config, set `{reconfigure: true}` in sheet.object(\"".concat(key, '", config, {reconfigure: true})')
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (actions) {
|
|
existingObject.template._temp_setActions(actions);
|
|
}
|
|
return existingObject.publicApi;
|
|
} else {
|
|
const sanitizedConfig = compound(config);
|
|
const object = internal2.createObject(
|
|
sanitizedPath,
|
|
nativeObject,
|
|
sanitizedConfig,
|
|
actions
|
|
);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
weakMapOfUnsanitizedProps.set(object, config);
|
|
}
|
|
return object.publicApi;
|
|
}
|
|
}
|
|
__experimental_getExistingObject(key) {
|
|
const internal2 = privateAPI(this);
|
|
const sanitizedPath = validateAndSanitiseSlashedPathOrThrow(
|
|
key,
|
|
"sheet.object"
|
|
);
|
|
const existingObject = internal2.getObject(sanitizedPath);
|
|
return existingObject == null ? void 0 : existingObject.publicApi;
|
|
}
|
|
get sequence() {
|
|
return privateAPI(this).getSequence().publicApi;
|
|
}
|
|
get project() {
|
|
return privateAPI(this).project.publicApi;
|
|
}
|
|
get address() {
|
|
return __spreadValues({}, privateAPI(this).address);
|
|
}
|
|
detachObject(key) {
|
|
const internal2 = privateAPI(this);
|
|
const sanitizedPath = validateAndSanitiseSlashedPathOrThrow(
|
|
key,
|
|
'sheet.deleteObject("'.concat(key, '")')
|
|
);
|
|
const obj = internal2.getObject(sanitizedPath);
|
|
if (!obj) {
|
|
notify.warning(
|
|
"Couldn't delete object \"".concat(sanitizedPath, '"'),
|
|
'There is no object with key "'.concat(sanitizedPath, '".\n\nTo fix this, make sure you are calling `sheet.deleteObject("').concat(sanitizedPath, '")` with the correct key.')
|
|
);
|
|
console.warn('Object key "'.concat(sanitizedPath, '" does not exist.'));
|
|
return;
|
|
}
|
|
internal2.deleteObject(sanitizedPath);
|
|
}
|
|
};
|
|
|
|
// core/src/sheets/Sheet.ts
|
|
var import_dataverse14 = require("@theatre/dataverse");
|
|
var Sheet = class {
|
|
constructor(template, instanceId) {
|
|
this.template = template;
|
|
this.instanceId = instanceId;
|
|
__publicField(this, "_objects", new import_dataverse14.Atom({}));
|
|
__publicField(this, "_sequence");
|
|
__publicField(this, "address");
|
|
__publicField(this, "publicApi");
|
|
__publicField(this, "project");
|
|
__publicField(this, "objectsP", this._objects.pointer);
|
|
__publicField(this, "type", "Theatre_Sheet");
|
|
__publicField(this, "_logger");
|
|
this._logger = template.project._logger.named("Sheet", instanceId);
|
|
this._logger._trace("creating sheet");
|
|
this.project = template.project;
|
|
this.address = __spreadProps(__spreadValues({}, template.address), {
|
|
sheetInstanceId: this.instanceId
|
|
});
|
|
this.publicApi = new TheatreSheet(this);
|
|
}
|
|
/**
|
|
* @remarks At some point, we have to reconcile the concept of "an object"
|
|
* with that of "an element."
|
|
*/
|
|
createObject(objectKey, nativeObject, config, actions = {}) {
|
|
const objTemplate = this.template.getObjectTemplate(
|
|
objectKey,
|
|
nativeObject,
|
|
config,
|
|
actions
|
|
);
|
|
const object = objTemplate.createInstance(this, nativeObject, config);
|
|
this._objects.setByPointer((p2) => p2[objectKey], object);
|
|
return object;
|
|
}
|
|
getObject(key) {
|
|
return this._objects.get()[key];
|
|
}
|
|
deleteObject(objectKey) {
|
|
this._objects.reduce((state) => {
|
|
const newState = __spreadValues({}, state);
|
|
delete newState[objectKey];
|
|
return newState;
|
|
});
|
|
}
|
|
getSequence() {
|
|
if (!this._sequence) {
|
|
const lengthD = (0, import_dataverse14.prism)(() => {
|
|
const unsanitized = (0, import_dataverse14.val)(
|
|
this.project.pointers.historic.sheetsById[this.address.sheetId].sequence.length
|
|
);
|
|
return sanitizeSequenceLength(unsanitized);
|
|
});
|
|
const subUnitsPerUnitD = (0, import_dataverse14.prism)(() => {
|
|
const unsanitized = (0, import_dataverse14.val)(
|
|
this.project.pointers.historic.sheetsById[this.address.sheetId].sequence.subUnitsPerUnit
|
|
);
|
|
return sanitizeSequenceSubUnitsPerUnit(unsanitized);
|
|
});
|
|
this._sequence = new Sequence(
|
|
this.template.project,
|
|
this,
|
|
lengthD,
|
|
subUnitsPerUnitD
|
|
);
|
|
}
|
|
return this._sequence;
|
|
}
|
|
};
|
|
var sanitizeSequenceLength = (len) => typeof len === "number" && isFinite(len) && len > 0 ? len : 10;
|
|
var sanitizeSequenceSubUnitsPerUnit = (subs) => typeof subs === "number" && isInteger_default(subs) && subs >= 1 && subs <= 1e3 ? subs : 30;
|
|
|
|
// core/src/sheets/SheetTemplate.ts
|
|
var SheetTemplate = class {
|
|
constructor(project, sheetId) {
|
|
this.project = project;
|
|
__publicField(this, "type", "Theatre_SheetTemplate");
|
|
__publicField(this, "address");
|
|
__publicField(this, "_instances", new import_dataverse15.Atom({}));
|
|
__publicField(this, "instancesP", this._instances.pointer);
|
|
__publicField(this, "_objectTemplates", new import_dataverse15.Atom({}));
|
|
__publicField(this, "objectTemplatesP", this._objectTemplates.pointer);
|
|
this.address = __spreadProps(__spreadValues({}, project.address), { sheetId });
|
|
}
|
|
getInstance(instanceId) {
|
|
let inst = this._instances.get()[instanceId];
|
|
if (!inst) {
|
|
inst = new Sheet(this, instanceId);
|
|
this._instances.setByPointer((p2) => p2[instanceId], inst);
|
|
}
|
|
return inst;
|
|
}
|
|
getObjectTemplate(objectKey, nativeObject, config, actions) {
|
|
let template = this._objectTemplates.get()[objectKey];
|
|
if (!template) {
|
|
template = new SheetObjectTemplate(
|
|
this,
|
|
objectKey,
|
|
nativeObject,
|
|
config,
|
|
actions
|
|
);
|
|
this._objectTemplates.setByPointer((p2) => p2[objectKey], template);
|
|
}
|
|
return template;
|
|
}
|
|
};
|
|
|
|
// core/src/projects/Project.ts
|
|
var import_dataverse16 = require("@theatre/dataverse");
|
|
var import_dataverse17 = require("@theatre/dataverse");
|
|
|
|
// shared/src/utils/delay.ts
|
|
var delay = (dur) => new Promise((resolve) => setTimeout(resolve, dur));
|
|
var delay_default = delay;
|
|
|
|
// ../node_modules/immer/dist/immer.esm.js
|
|
function n(n2) {
|
|
for (var t2 = arguments.length, r2 = Array(t2 > 1 ? t2 - 1 : 0), e2 = 1; e2 < t2; e2++)
|
|
r2[e2 - 1] = arguments[e2];
|
|
if ("production" !== process.env.NODE_ENV) {
|
|
var i2 = Y[n2], o2 = i2 ? "function" == typeof i2 ? i2.apply(null, r2) : i2 : "unknown error nr: " + n2;
|
|
throw Error("[Immer] " + o2);
|
|
}
|
|
throw Error("[Immer] minified error nr: " + n2 + (r2.length ? " " + r2.map(function(n3) {
|
|
return "'" + n3 + "'";
|
|
}).join(",") : "") + ". Find the full error at: https://bit.ly/3cXEKWf");
|
|
}
|
|
function t(n2) {
|
|
return !!n2 && !!n2[Q];
|
|
}
|
|
function r(n2) {
|
|
return !!n2 && (function(n3) {
|
|
if (!n3 || "object" != typeof n3)
|
|
return false;
|
|
var t2 = Object.getPrototypeOf(n3);
|
|
if (null === t2)
|
|
return true;
|
|
var r2 = Object.hasOwnProperty.call(t2, "constructor") && t2.constructor;
|
|
return r2 === Object || "function" == typeof r2 && Function.toString.call(r2) === Z;
|
|
}(n2) || Array.isArray(n2) || !!n2[L] || !!n2.constructor[L] || s(n2) || v(n2));
|
|
}
|
|
function e(r2) {
|
|
return t(r2) || n(23, r2), r2[Q].t;
|
|
}
|
|
function i(n2, t2, r2) {
|
|
void 0 === r2 && (r2 = false), 0 === o(n2) ? (r2 ? Object.keys : nn)(n2).forEach(function(e2) {
|
|
r2 && "symbol" == typeof e2 || t2(e2, n2[e2], n2);
|
|
}) : n2.forEach(function(r3, e2) {
|
|
return t2(e2, r3, n2);
|
|
});
|
|
}
|
|
function o(n2) {
|
|
var t2 = n2[Q];
|
|
return t2 ? t2.i > 3 ? t2.i - 4 : t2.i : Array.isArray(n2) ? 1 : s(n2) ? 2 : v(n2) ? 3 : 0;
|
|
}
|
|
function u(n2, t2) {
|
|
return 2 === o(n2) ? n2.has(t2) : Object.prototype.hasOwnProperty.call(n2, t2);
|
|
}
|
|
function a(n2, t2) {
|
|
return 2 === o(n2) ? n2.get(t2) : n2[t2];
|
|
}
|
|
function f(n2, t2, r2) {
|
|
var e2 = o(n2);
|
|
2 === e2 ? n2.set(t2, r2) : 3 === e2 ? (n2.delete(t2), n2.add(r2)) : n2[t2] = r2;
|
|
}
|
|
function c(n2, t2) {
|
|
return n2 === t2 ? 0 !== n2 || 1 / n2 == 1 / t2 : n2 != n2 && t2 != t2;
|
|
}
|
|
function s(n2) {
|
|
return X && n2 instanceof Map;
|
|
}
|
|
function v(n2) {
|
|
return q && n2 instanceof Set;
|
|
}
|
|
function p(n2) {
|
|
return n2.o || n2.t;
|
|
}
|
|
function l(n2) {
|
|
if (Array.isArray(n2))
|
|
return Array.prototype.slice.call(n2);
|
|
var t2 = tn(n2);
|
|
delete t2[Q];
|
|
for (var r2 = nn(t2), e2 = 0; e2 < r2.length; e2++) {
|
|
var i2 = r2[e2], o2 = t2[i2];
|
|
false === o2.writable && (o2.writable = true, o2.configurable = true), (o2.get || o2.set) && (t2[i2] = { configurable: true, writable: true, enumerable: o2.enumerable, value: n2[i2] });
|
|
}
|
|
return Object.create(Object.getPrototypeOf(n2), t2);
|
|
}
|
|
function d(n2, e2) {
|
|
return void 0 === e2 && (e2 = false), y(n2) || t(n2) || !r(n2) ? n2 : (o(n2) > 1 && (n2.set = n2.add = n2.clear = n2.delete = h), Object.freeze(n2), e2 && i(n2, function(n3, t2) {
|
|
return d(t2, true);
|
|
}, true), n2);
|
|
}
|
|
function h() {
|
|
n(2);
|
|
}
|
|
function y(n2) {
|
|
return null == n2 || "object" != typeof n2 || Object.isFrozen(n2);
|
|
}
|
|
function b(t2) {
|
|
var r2 = rn[t2];
|
|
return r2 || n(18, t2), r2;
|
|
}
|
|
function _() {
|
|
return "production" === process.env.NODE_ENV || U || n(0), U;
|
|
}
|
|
function j(n2, t2) {
|
|
t2 && (b("Patches"), n2.u = [], n2.s = [], n2.v = t2);
|
|
}
|
|
function O(n2) {
|
|
g(n2), n2.p.forEach(S), n2.p = null;
|
|
}
|
|
function g(n2) {
|
|
n2 === U && (U = n2.l);
|
|
}
|
|
function w(n2) {
|
|
return U = { p: [], l: U, h: n2, m: true, _: 0 };
|
|
}
|
|
function S(n2) {
|
|
var t2 = n2[Q];
|
|
0 === t2.i || 1 === t2.i ? t2.j() : t2.O = true;
|
|
}
|
|
function P(t2, e2) {
|
|
e2._ = e2.p.length;
|
|
var i2 = e2.p[0], o2 = void 0 !== t2 && t2 !== i2;
|
|
return e2.h.g || b("ES5").S(e2, t2, o2), o2 ? (i2[Q].P && (O(e2), n(4)), r(t2) && (t2 = M(e2, t2), e2.l || x(e2, t2)), e2.u && b("Patches").M(i2[Q], t2, e2.u, e2.s)) : t2 = M(e2, i2, []), O(e2), e2.u && e2.v(e2.u, e2.s), t2 !== H ? t2 : void 0;
|
|
}
|
|
function M(n2, t2, r2) {
|
|
if (y(t2))
|
|
return t2;
|
|
var e2 = t2[Q];
|
|
if (!e2)
|
|
return i(t2, function(i2, o3) {
|
|
return A(n2, e2, t2, i2, o3, r2);
|
|
}, true), t2;
|
|
if (e2.A !== n2)
|
|
return t2;
|
|
if (!e2.P)
|
|
return x(n2, e2.t, true), e2.t;
|
|
if (!e2.I) {
|
|
e2.I = true, e2.A._--;
|
|
var o2 = 4 === e2.i || 5 === e2.i ? e2.o = l(e2.k) : e2.o;
|
|
i(3 === e2.i ? new Set(o2) : o2, function(t3, i2) {
|
|
return A(n2, e2, o2, t3, i2, r2);
|
|
}), x(n2, o2, false), r2 && n2.u && b("Patches").R(e2, r2, n2.u, n2.s);
|
|
}
|
|
return e2.o;
|
|
}
|
|
function A(e2, i2, o2, a2, c2, s2) {
|
|
if ("production" !== process.env.NODE_ENV && c2 === o2 && n(5), t(c2)) {
|
|
var v2 = M(e2, c2, s2 && i2 && 3 !== i2.i && !u(i2.D, a2) ? s2.concat(a2) : void 0);
|
|
if (f(o2, a2, v2), !t(v2))
|
|
return;
|
|
e2.m = false;
|
|
}
|
|
if (r(c2) && !y(c2)) {
|
|
if (!e2.h.F && e2._ < 1)
|
|
return;
|
|
M(e2, c2), i2 && i2.A.l || x(e2, c2);
|
|
}
|
|
}
|
|
function x(n2, t2, r2) {
|
|
void 0 === r2 && (r2 = false), n2.h.F && n2.m && d(t2, r2);
|
|
}
|
|
function z(n2, t2) {
|
|
var r2 = n2[Q];
|
|
return (r2 ? p(r2) : n2)[t2];
|
|
}
|
|
function I(n2, t2) {
|
|
if (t2 in n2)
|
|
for (var r2 = Object.getPrototypeOf(n2); r2; ) {
|
|
var e2 = Object.getOwnPropertyDescriptor(r2, t2);
|
|
if (e2)
|
|
return e2;
|
|
r2 = Object.getPrototypeOf(r2);
|
|
}
|
|
}
|
|
function k(n2) {
|
|
n2.P || (n2.P = true, n2.l && k(n2.l));
|
|
}
|
|
function E(n2) {
|
|
n2.o || (n2.o = l(n2.t));
|
|
}
|
|
function R(n2, t2, r2) {
|
|
var e2 = s(t2) ? b("MapSet").N(t2, r2) : v(t2) ? b("MapSet").T(t2, r2) : n2.g ? function(n3, t3) {
|
|
var r3 = Array.isArray(n3), e3 = { i: r3 ? 1 : 0, A: t3 ? t3.A : _(), P: false, I: false, D: {}, l: t3, t: n3, k: null, o: null, j: null, C: false }, i2 = e3, o2 = en;
|
|
r3 && (i2 = [e3], o2 = on);
|
|
var u2 = Proxy.revocable(i2, o2), a2 = u2.revoke, f2 = u2.proxy;
|
|
return e3.k = f2, e3.j = a2, f2;
|
|
}(t2, r2) : b("ES5").J(t2, r2);
|
|
return (r2 ? r2.A : _()).p.push(e2), e2;
|
|
}
|
|
function D(e2) {
|
|
return t(e2) || n(22, e2), function n2(t2) {
|
|
if (!r(t2))
|
|
return t2;
|
|
var e3, u2 = t2[Q], c2 = o(t2);
|
|
if (u2) {
|
|
if (!u2.P && (u2.i < 4 || !b("ES5").K(u2)))
|
|
return u2.t;
|
|
u2.I = true, e3 = F(t2, c2), u2.I = false;
|
|
} else
|
|
e3 = F(t2, c2);
|
|
return i(e3, function(t3, r2) {
|
|
u2 && a(u2.t, t3) === r2 || f(e3, t3, n2(r2));
|
|
}), 3 === c2 ? new Set(e3) : e3;
|
|
}(e2);
|
|
}
|
|
function F(n2, t2) {
|
|
switch (t2) {
|
|
case 2:
|
|
return new Map(n2);
|
|
case 3:
|
|
return Array.from(n2);
|
|
}
|
|
return l(n2);
|
|
}
|
|
var G;
|
|
var U;
|
|
var W = "undefined" != typeof Symbol && "symbol" == typeof Symbol("x");
|
|
var X = "undefined" != typeof Map;
|
|
var q = "undefined" != typeof Set;
|
|
var B = "undefined" != typeof Proxy && void 0 !== Proxy.revocable && "undefined" != typeof Reflect;
|
|
var H = W ? Symbol.for("immer-nothing") : ((G = {})["immer-nothing"] = true, G);
|
|
var L = W ? Symbol.for("immer-draftable") : "__$immer_draftable";
|
|
var Q = W ? Symbol.for("immer-state") : "__$immer_state";
|
|
var Y = { 0: "Illegal state", 1: "Immer drafts cannot have computed properties", 2: "This object has been frozen and should not be mutated", 3: function(n2) {
|
|
return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + n2;
|
|
}, 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", 5: "Immer forbids circular references", 6: "The first or second argument to `produce` must be a function", 7: "The third argument to `produce` must be a function or undefined", 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", 10: "The given draft is already finalized", 11: "Object.defineProperty() cannot be used on an Immer draft", 12: "Object.setPrototypeOf() cannot be used on an Immer draft", 13: "Immer only supports deleting array indices", 14: "Immer only supports setting array indices and the 'length' property", 15: function(n2) {
|
|
return "Cannot apply patch, path doesn't resolve: " + n2;
|
|
}, 16: 'Sets cannot have "replace" patches.', 17: function(n2) {
|
|
return "Unsupported patch operation: " + n2;
|
|
}, 18: function(n2) {
|
|
return "The plugin for '" + n2 + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + n2 + "()` when initializing your application.";
|
|
}, 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", 21: function(n2) {
|
|
return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '" + n2 + "'";
|
|
}, 22: function(n2) {
|
|
return "'current' expects a draft, got: " + n2;
|
|
}, 23: function(n2) {
|
|
return "'original' expects a draft, got: " + n2;
|
|
}, 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" };
|
|
var Z = "" + Object.prototype.constructor;
|
|
var nn = "undefined" != typeof Reflect && Reflect.ownKeys ? Reflect.ownKeys : void 0 !== Object.getOwnPropertySymbols ? function(n2) {
|
|
return Object.getOwnPropertyNames(n2).concat(Object.getOwnPropertySymbols(n2));
|
|
} : Object.getOwnPropertyNames;
|
|
var tn = Object.getOwnPropertyDescriptors || function(n2) {
|
|
var t2 = {};
|
|
return nn(n2).forEach(function(r2) {
|
|
t2[r2] = Object.getOwnPropertyDescriptor(n2, r2);
|
|
}), t2;
|
|
};
|
|
var rn = {};
|
|
var en = { get: function(n2, t2) {
|
|
if (t2 === Q)
|
|
return n2;
|
|
var e2 = p(n2);
|
|
if (!u(e2, t2))
|
|
return function(n3, t3, r2) {
|
|
var e3, i3 = I(t3, r2);
|
|
return i3 ? "value" in i3 ? i3.value : null === (e3 = i3.get) || void 0 === e3 ? void 0 : e3.call(n3.k) : void 0;
|
|
}(n2, e2, t2);
|
|
var i2 = e2[t2];
|
|
return n2.I || !r(i2) ? i2 : i2 === z(n2.t, t2) ? (E(n2), n2.o[t2] = R(n2.A.h, i2, n2)) : i2;
|
|
}, has: function(n2, t2) {
|
|
return t2 in p(n2);
|
|
}, ownKeys: function(n2) {
|
|
return Reflect.ownKeys(p(n2));
|
|
}, set: function(n2, t2, r2) {
|
|
var e2 = I(p(n2), t2);
|
|
if (null == e2 ? void 0 : e2.set)
|
|
return e2.set.call(n2.k, r2), true;
|
|
if (!n2.P) {
|
|
var i2 = z(p(n2), t2), o2 = null == i2 ? void 0 : i2[Q];
|
|
if (o2 && o2.t === r2)
|
|
return n2.o[t2] = r2, n2.D[t2] = false, true;
|
|
if (c(r2, i2) && (void 0 !== r2 || u(n2.t, t2)))
|
|
return true;
|
|
E(n2), k(n2);
|
|
}
|
|
return n2.o[t2] === r2 && "number" != typeof r2 && (void 0 !== r2 || t2 in n2.o) || (n2.o[t2] = r2, n2.D[t2] = true, true);
|
|
}, deleteProperty: function(n2, t2) {
|
|
return void 0 !== z(n2.t, t2) || t2 in n2.t ? (n2.D[t2] = false, E(n2), k(n2)) : delete n2.D[t2], n2.o && delete n2.o[t2], true;
|
|
}, getOwnPropertyDescriptor: function(n2, t2) {
|
|
var r2 = p(n2), e2 = Reflect.getOwnPropertyDescriptor(r2, t2);
|
|
return e2 ? { writable: true, configurable: 1 !== n2.i || "length" !== t2, enumerable: e2.enumerable, value: r2[t2] } : e2;
|
|
}, defineProperty: function() {
|
|
n(11);
|
|
}, getPrototypeOf: function(n2) {
|
|
return Object.getPrototypeOf(n2.t);
|
|
}, setPrototypeOf: function() {
|
|
n(12);
|
|
} };
|
|
var on = {};
|
|
i(en, function(n2, t2) {
|
|
on[n2] = function() {
|
|
return arguments[0] = arguments[0][0], t2.apply(this, arguments);
|
|
};
|
|
}), on.deleteProperty = function(t2, r2) {
|
|
return "production" !== process.env.NODE_ENV && isNaN(parseInt(r2)) && n(13), en.deleteProperty.call(this, t2[0], r2);
|
|
}, on.set = function(t2, r2, e2) {
|
|
return "production" !== process.env.NODE_ENV && "length" !== r2 && isNaN(parseInt(r2)) && n(14), en.set.call(this, t2[0], r2, e2, t2[0]);
|
|
};
|
|
var un = function() {
|
|
function e2(t2) {
|
|
var e3 = this;
|
|
this.g = B, this.F = true, this.produce = function(t3, i3, o2) {
|
|
if ("function" == typeof t3 && "function" != typeof i3) {
|
|
var u2 = i3;
|
|
i3 = t3;
|
|
var a2 = e3;
|
|
return function(n2) {
|
|
var t4 = this;
|
|
void 0 === n2 && (n2 = u2);
|
|
for (var r2 = arguments.length, e4 = Array(r2 > 1 ? r2 - 1 : 0), o3 = 1; o3 < r2; o3++)
|
|
e4[o3 - 1] = arguments[o3];
|
|
return a2.produce(n2, function(n3) {
|
|
var r3;
|
|
return (r3 = i3).call.apply(r3, [t4, n3].concat(e4));
|
|
});
|
|
};
|
|
}
|
|
var f2;
|
|
if ("function" != typeof i3 && n(6), void 0 !== o2 && "function" != typeof o2 && n(7), r(t3)) {
|
|
var c2 = w(e3), s2 = R(e3, t3, void 0), v2 = true;
|
|
try {
|
|
f2 = i3(s2), v2 = false;
|
|
} finally {
|
|
v2 ? O(c2) : g(c2);
|
|
}
|
|
return "undefined" != typeof Promise && f2 instanceof Promise ? f2.then(function(n2) {
|
|
return j(c2, o2), P(n2, c2);
|
|
}, function(n2) {
|
|
throw O(c2), n2;
|
|
}) : (j(c2, o2), P(f2, c2));
|
|
}
|
|
if (!t3 || "object" != typeof t3) {
|
|
if ((f2 = i3(t3)) === H)
|
|
return;
|
|
return void 0 === f2 && (f2 = t3), e3.F && d(f2, true), f2;
|
|
}
|
|
n(21, t3);
|
|
}, this.produceWithPatches = function(n2, t3) {
|
|
return "function" == typeof n2 ? function(t4) {
|
|
for (var r3 = arguments.length, i4 = Array(r3 > 1 ? r3 - 1 : 0), o2 = 1; o2 < r3; o2++)
|
|
i4[o2 - 1] = arguments[o2];
|
|
return e3.produceWithPatches(t4, function(t5) {
|
|
return n2.apply(void 0, [t5].concat(i4));
|
|
});
|
|
} : [e3.produce(n2, t3, function(n3, t4) {
|
|
r2 = n3, i3 = t4;
|
|
}), r2, i3];
|
|
var r2, i3;
|
|
}, "boolean" == typeof (null == t2 ? void 0 : t2.useProxies) && this.setUseProxies(t2.useProxies), "boolean" == typeof (null == t2 ? void 0 : t2.autoFreeze) && this.setAutoFreeze(t2.autoFreeze);
|
|
}
|
|
var i2 = e2.prototype;
|
|
return i2.createDraft = function(e3) {
|
|
r(e3) || n(8), t(e3) && (e3 = D(e3));
|
|
var i3 = w(this), o2 = R(this, e3, void 0);
|
|
return o2[Q].C = true, g(i3), o2;
|
|
}, i2.finishDraft = function(t2, r2) {
|
|
var e3 = t2 && t2[Q];
|
|
"production" !== process.env.NODE_ENV && (e3 && e3.C || n(9), e3.I && n(10));
|
|
var i3 = e3.A;
|
|
return j(i3, r2), P(void 0, i3);
|
|
}, i2.setAutoFreeze = function(n2) {
|
|
this.F = n2;
|
|
}, i2.setUseProxies = function(t2) {
|
|
t2 && !B && n(20), this.g = t2;
|
|
}, i2.applyPatches = function(n2, r2) {
|
|
var e3;
|
|
for (e3 = r2.length - 1; e3 >= 0; e3--) {
|
|
var i3 = r2[e3];
|
|
if (0 === i3.path.length && "replace" === i3.op) {
|
|
n2 = i3.value;
|
|
break;
|
|
}
|
|
}
|
|
var o2 = b("Patches").$;
|
|
return t(n2) ? o2(n2, r2) : this.produce(n2, function(n3) {
|
|
return o2(n3, r2.slice(e3 + 1));
|
|
});
|
|
}, e2;
|
|
}();
|
|
var an = new un();
|
|
var fn = an.produce;
|
|
var cn = an.produceWithPatches.bind(an);
|
|
var sn = an.setAutoFreeze.bind(an);
|
|
var vn = an.setUseProxies.bind(an);
|
|
var pn = an.applyPatches.bind(an);
|
|
var ln = an.createDraft.bind(an);
|
|
var dn = an.finishDraft.bind(an);
|
|
|
|
// shared/src/globals.ts
|
|
var globals = {
|
|
/**
|
|
* If the schema of the redux store changes in a backwards-incompatible way, then this version number should be incremented.
|
|
*
|
|
* While this looks like semver, it is not. There are no patch numbers, so any change in this number is a breaking change.
|
|
*
|
|
* However, as long as the schema of the redux store is backwards-compatible, then we don't have to change this number.
|
|
*
|
|
* Since the 0.4.0 release, this number has not had to change.
|
|
*/
|
|
currentProjectStateDefinitionVersion: "0.4.0"
|
|
};
|
|
var globals_default = globals;
|
|
|
|
// core/src/projects/initialiseProjectState.ts
|
|
async function initialiseProjectState(studio, project, onDiskState) {
|
|
await delay_default(0);
|
|
studio.transaction(({ drafts }) => {
|
|
var _a;
|
|
const projectId = project.address.projectId;
|
|
drafts.ephemeral.coreByProject[projectId] = {
|
|
lastExportedObject: null,
|
|
loadingState: { type: "loading" }
|
|
};
|
|
drafts.ahistoric.coreByProject[projectId] = {
|
|
ahistoricStuff: ""
|
|
};
|
|
function useInitialState() {
|
|
drafts.ephemeral.coreByProject[projectId].loadingState = {
|
|
type: "loaded"
|
|
};
|
|
drafts.historic.coreByProject[projectId] = {
|
|
sheetsById: {},
|
|
definitionVersion: globals_default.currentProjectStateDefinitionVersion,
|
|
revisionHistory: []
|
|
};
|
|
}
|
|
function useOnDiskState(state) {
|
|
drafts.ephemeral.coreByProject[projectId].loadingState = {
|
|
type: "loaded"
|
|
};
|
|
drafts.historic.coreByProject[projectId] = state;
|
|
}
|
|
function useBrowserState() {
|
|
drafts.ephemeral.coreByProject[projectId].loadingState = {
|
|
type: "loaded"
|
|
};
|
|
}
|
|
function browserStateIsNotBasedOnDiskState(onDiskState2) {
|
|
drafts.ephemeral.coreByProject[projectId].loadingState = {
|
|
type: "browserStateIsNotBasedOnDiskState",
|
|
onDiskState: onDiskState2
|
|
};
|
|
}
|
|
const browserState = (_a = e(drafts.historic)) == null ? void 0 : _a.coreByProject[project.address.projectId];
|
|
if (!browserState) {
|
|
if (!onDiskState) {
|
|
useInitialState();
|
|
} else {
|
|
useOnDiskState(onDiskState);
|
|
}
|
|
} else {
|
|
if (!onDiskState) {
|
|
useBrowserState();
|
|
} else {
|
|
if (browserState.revisionHistory.indexOf(
|
|
onDiskState.revisionHistory[0]
|
|
) == -1) {
|
|
browserStateIsNotBasedOnDiskState(onDiskState);
|
|
} else {
|
|
useBrowserState();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// core/src/_coreLogger.ts
|
|
function noop2() {
|
|
}
|
|
function _coreLogger(config) {
|
|
var _a, _b;
|
|
const internalMin = ((_a = config == null ? void 0 : config.logging) == null ? void 0 : _a.internal) ? (_b = config.logging.min) != null ? _b : 256 /* WARN */ : Infinity;
|
|
const shouldDebugLogger = internalMin <= 128 /* DEBUG */;
|
|
const shouldShowLoggerErrors = internalMin <= 512 /* ERROR */;
|
|
const internal2 = createTheatreInternalLogger(void 0, {
|
|
_debug: shouldDebugLogger ? console.debug.bind(console, "_coreLogger(TheatreInternalLogger) debug") : noop2,
|
|
_error: shouldShowLoggerErrors ? console.error.bind(console, "_coreLogger(TheatreInternalLogger) error") : noop2
|
|
});
|
|
if (config) {
|
|
const { logger, logging } = config;
|
|
if (logger)
|
|
internal2.configureLogger(logger);
|
|
if (logging)
|
|
internal2.configureLogging(logging);
|
|
else {
|
|
internal2.configureLogging({
|
|
dev: process.env.NODE_ENV !== "production"
|
|
});
|
|
}
|
|
}
|
|
return internal2.getLogger().named("Theatre");
|
|
}
|
|
|
|
// core/src/projects/Project.ts
|
|
var Project = class {
|
|
constructor(id, config = {}, publicApi) {
|
|
this.config = config;
|
|
this.publicApi = publicApi;
|
|
__publicField(this, "pointers");
|
|
__publicField(this, "_pointerProxies");
|
|
__publicField(this, "address");
|
|
__publicField(this, "_studioReadyDeferred");
|
|
__publicField(this, "_assetStorageReadyDeferred");
|
|
__publicField(this, "_readyPromise");
|
|
__publicField(this, "_sheetTemplates", new import_dataverse17.Atom({}));
|
|
__publicField(this, "sheetTemplatesP", this._sheetTemplates.pointer);
|
|
__publicField(this, "_studio");
|
|
__publicField(this, "assetStorage");
|
|
__publicField(this, "type", "Theatre_Project");
|
|
__publicField(this, "_logger");
|
|
var _a;
|
|
this._logger = _coreLogger({ logging: { dev: true } }).named("Project", id);
|
|
this._logger.traceDev("creating project");
|
|
this.address = { projectId: id };
|
|
const onDiskStateAtom = new import_dataverse17.Atom({
|
|
ahistoric: {
|
|
ahistoricStuff: ""
|
|
},
|
|
historic: (_a = config.state) != null ? _a : {
|
|
sheetsById: {},
|
|
definitionVersion: globals_default.currentProjectStateDefinitionVersion,
|
|
revisionHistory: []
|
|
},
|
|
ephemeral: {
|
|
loadingState: {
|
|
type: "loaded"
|
|
},
|
|
lastExportedObject: null
|
|
}
|
|
});
|
|
this._assetStorageReadyDeferred = defer();
|
|
this.assetStorage = {
|
|
getAssetUrl: (assetId) => {
|
|
var _a2;
|
|
return "".concat((_a2 = config.assets) == null ? void 0 : _a2.baseUrl, "/").concat(assetId);
|
|
},
|
|
// Until the asset storage is ready, we'll throw an error when the user tries to use it
|
|
createAsset: () => {
|
|
throw new Error("Please wait for Project.ready to use assets.");
|
|
}
|
|
};
|
|
this._pointerProxies = {
|
|
historic: new import_dataverse16.PointerProxy(onDiskStateAtom.pointer.historic),
|
|
ahistoric: new import_dataverse16.PointerProxy(onDiskStateAtom.pointer.ahistoric),
|
|
ephemeral: new import_dataverse16.PointerProxy(onDiskStateAtom.pointer.ephemeral)
|
|
};
|
|
this.pointers = {
|
|
historic: this._pointerProxies.historic.pointer,
|
|
ahistoric: this._pointerProxies.ahistoric.pointer,
|
|
ephemeral: this._pointerProxies.ephemeral.pointer
|
|
};
|
|
projectsSingleton_default.add(id, this);
|
|
this._studioReadyDeferred = defer();
|
|
this._readyPromise = Promise.all([
|
|
this._studioReadyDeferred.promise,
|
|
this._assetStorageReadyDeferred.promise
|
|
// hide the array from the user, i.e. make it Promise<void> instead of Promise<[undefined, undefined]>
|
|
]).then(() => {
|
|
});
|
|
if (config.state) {
|
|
setTimeout(() => {
|
|
if (!this._studio) {
|
|
this._studioReadyDeferred.resolve(void 0);
|
|
this._assetStorageReadyDeferred.resolve(void 0);
|
|
this._logger._trace("ready deferred resolved with no state");
|
|
}
|
|
}, 0);
|
|
} else {
|
|
if (typeof window === "undefined") {
|
|
if (process.env.NODE_ENV === "production") {
|
|
console.error(
|
|
'Argument config.state in Theatre.getProject("'.concat(id, '", config) is empty. ') + "You can safely ignore this message if you're developing a Next.js/Remix project in development mode. But if you are shipping to your end-users, then you need to set config.state, otherwise your project's state will be empty and nothing will animate. Learn more at https://www.theatrejs.com/docs/latest/manual/projects#state"
|
|
);
|
|
}
|
|
} else {
|
|
setTimeout(() => {
|
|
if (!this._studio) {
|
|
throw new Error(
|
|
'Argument config.state in Theatre.getProject("'.concat(id, '", config) is empty. This is fine ') + "while you are using @theatre/core along with @theatre/studio. But since @theatre/studio " + 'is not loaded, the state of project "'.concat(id, '" will be empty.\n\n') + "To fix this, you need to add @theatre/studio into the bundle and export the project's state. Learn how to do that at https://www.theatrejs.com/docs/latest/manual/projects#state\n"
|
|
);
|
|
}
|
|
}, 1e3);
|
|
}
|
|
}
|
|
}
|
|
attachToStudio(studio) {
|
|
if (this._studio) {
|
|
if (this._studio !== studio) {
|
|
throw new Error(
|
|
"Project ".concat(this.address.projectId, " is already attached to studio ").concat(this._studio.address.studioId)
|
|
);
|
|
} else {
|
|
console.warn(
|
|
"Project ".concat(this.address.projectId, " is already attached to studio ").concat(this._studio.address.studioId)
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
this._studio = studio;
|
|
studio.initialized.then(async () => {
|
|
var _a;
|
|
await initialiseProjectState(studio, this, this.config.state);
|
|
this._pointerProxies.historic.setPointer(
|
|
studio.atomP.historic.coreByProject[this.address.projectId]
|
|
);
|
|
this._pointerProxies.ahistoric.setPointer(
|
|
studio.atomP.ahistoric.coreByProject[this.address.projectId]
|
|
);
|
|
this._pointerProxies.ephemeral.setPointer(
|
|
studio.atomP.ephemeral.coreByProject[this.address.projectId]
|
|
);
|
|
await studio.createAssetStorage(this, (_a = this.config.assets) == null ? void 0 : _a.baseUrl).then((assetStorage) => {
|
|
this.assetStorage = assetStorage;
|
|
this._assetStorageReadyDeferred.resolve(void 0);
|
|
});
|
|
this._studioReadyDeferred.resolve(void 0);
|
|
}).catch((err) => {
|
|
console.error(err);
|
|
throw err;
|
|
});
|
|
}
|
|
get isAttachedToStudio() {
|
|
return !!this._studio;
|
|
}
|
|
get ready() {
|
|
return this._readyPromise;
|
|
}
|
|
isReady() {
|
|
return this._studioReadyDeferred.status === "resolved" && this._assetStorageReadyDeferred.status === "resolved";
|
|
}
|
|
getOrCreateSheet(sheetId, instanceId = "default") {
|
|
let template = this._sheetTemplates.get()[sheetId];
|
|
if (!template) {
|
|
template = new SheetTemplate(this, sheetId);
|
|
this._sheetTemplates.reduce((s2) => __spreadProps(__spreadValues({}, s2), { [sheetId]: template }));
|
|
}
|
|
return template.getInstance(instanceId);
|
|
}
|
|
};
|
|
|
|
// shared/src/utils/sanitizers.ts
|
|
var _validateSym = (val8, thingy, range) => {
|
|
if (typeof val8 !== "string") {
|
|
return "".concat(thingy, " must be a string. ").concat(userReadableTypeOfValue_default(val8), " given.");
|
|
} else if (val8.trim().length !== val8.length) {
|
|
return "".concat(thingy, " must not have leading or trailing spaces. '").concat(val8, "' given.");
|
|
} else if (val8.length < range[0] || val8.length > range[1]) {
|
|
return "".concat(thingy, " must have between ").concat(range[0], " and ").concat(range[1], " characters. '").concat(val8, "' given.");
|
|
}
|
|
};
|
|
var validateName = (name, thingy, shouldThrow = false) => {
|
|
const result = _validateSym(name, thingy, [3, 32]);
|
|
if (typeof result === "string" && shouldThrow) {
|
|
throw new InvalidArgumentError(result);
|
|
} else {
|
|
return result;
|
|
}
|
|
};
|
|
var validateInstanceId = (name, thingy, shouldThrow = false) => {
|
|
const result = _validateSym(name, thingy, [1, 32]);
|
|
if (typeof result === "string" && shouldThrow) {
|
|
throw new InvalidArgumentError(result);
|
|
} else {
|
|
return result;
|
|
}
|
|
};
|
|
|
|
// core/src/projects/TheatreProject.ts
|
|
var TheatreProject = class {
|
|
get type() {
|
|
return "Theatre_Project_PublicAPI";
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
constructor(id, config = {}) {
|
|
setPrivateAPI(this, new Project(id, config, this));
|
|
}
|
|
get ready() {
|
|
return privateAPI(this).ready;
|
|
}
|
|
get isReady() {
|
|
return privateAPI(this).isReady();
|
|
}
|
|
get address() {
|
|
return __spreadValues({}, privateAPI(this).address);
|
|
}
|
|
getAssetUrl(asset) {
|
|
if (!this.isReady) {
|
|
console.error(
|
|
"Calling `project.getAssetUrl()` before `project.ready` is resolved, will always return `undefined`. Either use `project.ready.then(() => project.getAssetUrl())` or `await project.ready` before calling `project.getAssetUrl()`."
|
|
);
|
|
return void 0;
|
|
}
|
|
return asset.id ? privateAPI(this).assetStorage.getAssetUrl(asset.id) : void 0;
|
|
}
|
|
sheet(sheetId, instanceId = "default") {
|
|
const sanitizedPath = validateAndSanitiseSlashedPathOrThrow(
|
|
sheetId,
|
|
"project.sheet"
|
|
);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateInstanceId(
|
|
instanceId,
|
|
"instanceId in project.sheet(sheetId, instanceId)",
|
|
true
|
|
);
|
|
}
|
|
return privateAPI(this).getOrCreateSheet(
|
|
sanitizedPath,
|
|
instanceId
|
|
).publicApi;
|
|
}
|
|
};
|
|
|
|
// core/src/coreExports.ts
|
|
var import_fast_deep_equal2 = __toESM(require_fast_deep_equal());
|
|
var import_dataverse18 = require("@theatre/dataverse");
|
|
var import_dataverse19 = require("@theatre/dataverse");
|
|
function getProject(id, config = {}) {
|
|
const existingProject = projectsSingleton_default.get(id);
|
|
if (existingProject) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (!(0, import_fast_deep_equal2.default)(config, existingProject.config)) {
|
|
throw new Error(
|
|
'You seem to have called Theatre.getProject("'.concat(id, '", config) twice, with different config objects. ') + "This is disallowed because changing the config of a project on the fly can lead to hard-to-debug issues.\n\nYou can fix this by either calling Theatre.getProject() once per projectId, or calling it multiple times but with the exact same config."
|
|
);
|
|
}
|
|
}
|
|
return existingProject.publicApi;
|
|
}
|
|
const rootLogger = _coreLogger();
|
|
const plogger = rootLogger.named("Project", id);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
validateName(id, "projectName in Theatre.getProject(projectName)", true);
|
|
validateProjectIdOrThrow(id);
|
|
plogger._debug("validated projectName", { projectName: id });
|
|
}
|
|
if (config.state) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
shallowValidateOnDiskState(id, config.state);
|
|
plogger._debug("shallow validated config.state on disk");
|
|
} else {
|
|
deepValidateOnDiskState(id, config.state);
|
|
plogger._debug("deep validated config.state on disk");
|
|
}
|
|
} else {
|
|
plogger._debug("no config.state");
|
|
}
|
|
return new TheatreProject(id, config);
|
|
}
|
|
var shallowValidateOnDiskState = (projectId, s2) => {
|
|
if (Array.isArray(s2) || s2 == null || s2.definitionVersion !== globals_default.currentProjectStateDefinitionVersion) {
|
|
throw new InvalidArgumentError(
|
|
"Error validating conf.state in Theatre.getProject(".concat(JSON.stringify(
|
|
projectId
|
|
), ", conf). The state seems to be formatted in a way that is unreadable to Theatre.js. Read more at https://www.theatrejs.com/docs/latest/manual/projects#state")
|
|
);
|
|
}
|
|
};
|
|
var deepValidateOnDiskState = (projectId, s2) => {
|
|
shallowValidateOnDiskState(projectId, s2);
|
|
};
|
|
var validateProjectIdOrThrow = (value) => {
|
|
if (typeof value !== "string") {
|
|
throw new InvalidArgumentError(
|
|
"Argument 'projectId' in `Theatre.getProject(projectId, ...)` must be a string. Instead, it was ".concat(userReadableTypeOfValue_default(
|
|
value
|
|
), ".")
|
|
);
|
|
}
|
|
const idTrimmed = value.trim();
|
|
if (idTrimmed.length !== value.length) {
|
|
throw new InvalidArgumentError(
|
|
"Argument 'projectId' in `Theatre.getProject(\"".concat(value, '", ...)` should not have surrounding whitespace.')
|
|
);
|
|
}
|
|
if (idTrimmed.length < 3) {
|
|
throw new InvalidArgumentError(
|
|
"Argument 'projectId' in `Theatre.getProject(\"".concat(value, '", ...)` should be at least 3 characters long.')
|
|
);
|
|
}
|
|
};
|
|
function onChange(pointer3, callback, rafDriver) {
|
|
const ticker = rafDriver ? privateAPI(rafDriver).ticker : getCoreTicker();
|
|
if ((0, import_dataverse18.isPointer)(pointer3)) {
|
|
const pr = (0, import_dataverse19.pointerToPrism)(pointer3);
|
|
return pr.onChange(ticker, callback, true);
|
|
} else if ((0, import_dataverse19.isPrism)(pointer3)) {
|
|
return pointer3.onChange(ticker, callback, true);
|
|
} else {
|
|
throw new Error(
|
|
"Called onChange(p) where p is neither a pointer nor a prism."
|
|
);
|
|
}
|
|
}
|
|
function val7(pointer3) {
|
|
if ((0, import_dataverse18.isPointer)(pointer3)) {
|
|
return (0, import_dataverse19.pointerToPrism)(pointer3).getValue();
|
|
} else {
|
|
throw new Error("Called val(p) where p is not a pointer.");
|
|
}
|
|
}
|
|
|
|
// core/src/CoreBundle.ts
|
|
var CoreBundle = class {
|
|
constructor() {
|
|
__publicField(this, "_studio");
|
|
}
|
|
get type() {
|
|
return "Theatre_CoreBundle";
|
|
}
|
|
get version() {
|
|
return "0.7.2";
|
|
}
|
|
getBitsForStudio(studio, callback) {
|
|
if (this._studio) {
|
|
throw new Error("@theatre/core is already attached to @theatre/studio");
|
|
}
|
|
this._studio = studio;
|
|
const bits = {
|
|
projectsP: projectsSingleton_default.atom.pointer.projects,
|
|
privateAPI,
|
|
coreExports: coreExports_exports,
|
|
getCoreRafDriver
|
|
};
|
|
callback(bits);
|
|
}
|
|
};
|
|
|
|
// core/src/index.ts
|
|
registerCoreBundle();
|
|
function registerCoreBundle() {
|
|
if (typeof window == "undefined")
|
|
return;
|
|
const existingBundle = (
|
|
// @ts-ignore ignore
|
|
window[coreBundle]
|
|
);
|
|
if (typeof existingBundle !== "undefined") {
|
|
if (typeof existingBundle === "object" && existingBundle && typeof existingBundle.version === "string") {
|
|
throw new Error(
|
|
"It seems that the module '@theatre/core' is loaded more than once. This could have two possible causes:\n1. You might have two separate versions of Theatre.js in node_modules.\n2. Or this might be a bundling misconfiguration, in case you're using a bundler like Webpack/ESBuild/Rollup.\n\nNote that it **is okay** to import '@theatre/core' multiple times. But those imports should point to the same module."
|
|
);
|
|
} else {
|
|
throw new Error(
|
|
"The variable window.".concat(coreBundle, " seems to be already set by a module other than @theatre/core.")
|
|
);
|
|
}
|
|
}
|
|
const coreBundle2 = new CoreBundle();
|
|
window[coreBundle] = coreBundle2;
|
|
const possibleExistingStudioBundle = (
|
|
// @ts-ignore ignore
|
|
window[studioBundle]
|
|
);
|
|
if (possibleExistingStudioBundle && possibleExistingStudioBundle !== null && possibleExistingStudioBundle.type === "Theatre_StudioBundle") {
|
|
possibleExistingStudioBundle.registerCoreBundle(coreBundle2);
|
|
}
|
|
}
|
|
/*! Bundled license information:
|
|
|
|
lodash-es/lodash.js:
|
|
(**
|
|
* @license
|
|
* Lodash (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modularize exports="es" -o ./`
|
|
* Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
|
|
* Released under MIT license <https://lodash.com/license>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
*)
|
|
*/
|
|
//# sourceMappingURL=index.js.map
|