one 2.10.0 → 2.11.1

package/dist/cjs/dom/serialize.cjs

@@ -0,0 +1,140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serialize_exports = {};
+__export(serialize_exports, {
+	DOMBridgeError: () => DOMBridgeError,
+	deserializeError: () => deserializeError,
+	serializeData: () => serializeData,
+	serializeError: () => serializeError,
+	serializeProps: () => serializeProps
+});
+module.exports = __toCommonJS(serialize_exports);
+var DOMBridgeError = class extends Error {
+	constructor(message, code = "DOM_PROTOCOL_ERROR") {
+		super(message);
+		this.code = code;
+		this.name = "DOMBridgeError";
+	}
+	code;
+};
+function invalid(path, reason) {
+	throw new DOMBridgeError(`${path}: ${reason}`, "DOM_SERIALIZATION_ERROR");
+}
+function serializeData(value, path = "$") {
+	const ancestors = /* @__PURE__ */ new Set();
+	function visit(item, at) {
+		if (item === null || typeof item === "string" || typeof item === "boolean") {
+			return item;
+		}
+		if (typeof item === "number" && Number.isFinite(item)) return item;
+		if (typeof item !== "object" || item === null) {
+			return invalid(at, `unsupported ${typeof item} value`);
+		}
+		if (ancestors.has(item)) return invalid(at, "cyclic value");
+		if (!Array.isArray(item)) {
+			const proto = Object.getPrototypeOf(item);
+			if (proto !== Object.prototype && proto !== null) {
+				return invalid(at, "expected a plain object");
+			}
+		}
+		if (Object.getOwnPropertySymbols(item).length) {
+			return invalid(at, "symbol properties are unsupported");
+		}
+		ancestors.add(item);
+		try {
+			if (Array.isArray(item)) {
+				return Array.from({ length: item.length }, (_, index) => {
+					const descriptor = Object.getOwnPropertyDescriptor(item, String(index));
+					if (!descriptor || !("value" in descriptor)) {
+						return invalid(`${at}[${index}]`, "array holes and accessors are unsupported");
+					}
+					return visit(descriptor.value, `${at}[${index}]`);
+				});
+			}
+			const result = /* @__PURE__ */ Object.create(null);
+			for (const key of Object.keys(item).sort()) {
+				const descriptor = Object.getOwnPropertyDescriptor(item, key);
+				const nextPath = `${at}[${JSON.stringify(key)}]`;
+				if (!("value" in descriptor)) return invalid(nextPath, "accessor is unsupported");
+				if (descriptor.value !== void 0) result[key] = visit(descriptor.value, nextPath);
+			}
+			return result;
+		} finally {
+			ancestors.delete(item);
+		}
+	}
+	return visit(value, path);
+}
+function serializeProps(props) {
+	const prototype = Object.getPrototypeOf(props);
+	if (prototype !== Object.prototype && prototype !== null || Object.getOwnPropertySymbols(props).length) {
+		invalid("props", "expected plain props with string property names");
+	}
+	const data = /* @__PURE__ */ Object.create(null);
+	const actions = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(props).sort()) {
+		const descriptor = Object.getOwnPropertyDescriptor(props, name);
+		if (!("value" in descriptor)) invalid(`props[${JSON.stringify(name)}]`, "accessor is unsupported");
+		const value = descriptor.value;
+		if (name === "children" && value !== void 0) {
+			invalid("props.children", "children cannot cross the DOM boundary");
+		}
+		if (typeof value === "function") actions.set(name, value);
+		else if (value !== void 0) data[name] = serializeData(value, `props[${JSON.stringify(name)}]`);
+	}
+	return {
+		props: data,
+		actions,
+		key: JSON.stringify([data, [...actions.keys()]])
+	};
+}
+function serializeError(error, development = false) {
+	let result = {
+		name: "Error",
+		message: "An unsupported error was thrown"
+	};
+	try {
+		if (error instanceof Error) {
+			result = {
+				name: String(error.name || "Error"),
+				message: String(error.message)
+			};
+			const code = error.code;
+			if (typeof code === "string") result.code = code;
+			if (development && typeof error.stack === "string") result.stack = error.stack;
+		} else if (error === null || [
+			"string",
+			"number",
+			"boolean",
+			"undefined",
+			"bigint"
+		].includes(typeof error)) {
+			result.message = String(error);
+		}
+	} catch {}
+	return result;
+}
+function deserializeError(error) {
+	const result = new DOMBridgeError(error.message, error.code || "DOM_REMOTE_ERROR");
+	result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	return result;
+}

package/dist/cjs/dom/serialize.native.cjs

@@ -0,0 +1,284 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serialize_exports = {};
+__export(serialize_exports, {
+	DOMBridgeError: () => DOMBridgeError,
+	deserializeError: () => deserializeError,
+	serializeData: () => serializeData,
+	serializeError: () => serializeError,
+	serializeProps: () => serializeProps
+});
+module.exports = __toCommonJS(serialize_exports);
+function _assert_this_initialized(self) {
+	if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	return self;
+}
+function _call_super(_this, derived, args) {
+	derived = _get_prototype_of(derived);
+	return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+	if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+	if (_is_native_reflect_construct()) _construct = Reflect.construct;
+	else {
+		_construct = function construct(Parent2, args2, Class2) {
+			var a = [null];
+			a.push.apply(a, args2);
+			var Constructor = Function.bind.apply(Parent2, a);
+			var instance = new Constructor();
+			if (Class2) _set_prototype_of(instance, Class2.prototype);
+			return instance;
+		};
+	}
+	return _construct.apply(null, arguments);
+}
+function _define_property(obj, key, value) {
+	if (key in obj) {
+		Object.defineProperty(obj, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	} else obj[key] = value;
+	return obj;
+}
+function _get_prototype_of(o) {
+	_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+		return o2.__proto__ || Object.getPrototypeOf(o2);
+	};
+	return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+	if (typeof superClass !== "function" && superClass !== null) {
+		throw new TypeError("Super expression must either be null or a function");
+	}
+	subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+		value: subClass,
+		writable: true,
+		configurable: true
+	} });
+	if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+	return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _is_native_reflect_construct() {
+	try {
+		var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+	} catch (_) {}
+	return (_is_native_reflect_construct = function() {
+		return !!result;
+	})();
+}
+function _possible_constructor_return(self, call) {
+	if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+	return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+	_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+		o2.__proto__ = p2;
+		return o2;
+	};
+	return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+	var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+	_wrap_native_super = function(Class2) {
+		if (Class2 === null || !_is_native_function(Class2)) return Class2;
+		if (typeof Class2 !== "function") throw new TypeError("Super expression must either be null or a function");
+		if (typeof _cache !== "undefined") {
+			if (_cache.has(Class2)) return _cache.get(Class2);
+			_cache.set(Class2, Wrapper);
+		}
+		function Wrapper() {
+			return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+		}
+		Wrapper.prototype = Object.create(Class2.prototype, { constructor: {
+			value: Wrapper,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		return _set_prototype_of(Wrapper, Class2);
+	};
+	return _wrap_native_super(Class);
+}
+var DOMBridgeError = /* @__PURE__ */ (function(Error1) {
+	"use strict";
+	_inherits(DOMBridgeError2, Error1);
+	function DOMBridgeError2(message) {
+		var code = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "DOM_PROTOCOL_ERROR";
+		_class_call_check(this, DOMBridgeError2);
+		var _this;
+		_this = _call_super(this, DOMBridgeError2, [message]), _define_property(_this, "code", void 0), _this.code = code;
+		_this.name = "DOMBridgeError";
+		return _this;
+	}
+	return DOMBridgeError2;
+})(_wrap_native_super(Error));
+function invalid(path, reason) {
+	throw new DOMBridgeError(`${path}: ${reason}`, "DOM_SERIALIZATION_ERROR");
+}
+function serializeData(value) {
+	var path = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "$";
+	var ancestors = /* @__PURE__ */ new Set();
+	function visit(item, at) {
+		if (item === null || typeof item === "string" || typeof item === "boolean") {
+			return item;
+		}
+		if (typeof item === "number" && Number.isFinite(item)) return item;
+		if (typeof item !== "object" || item === null) {
+			return invalid(at, `unsupported ${typeof item} value`);
+		}
+		if (ancestors.has(item)) return invalid(at, "cyclic value");
+		if (!Array.isArray(item)) {
+			var proto = Object.getPrototypeOf(item);
+			if (proto !== Object.prototype && proto !== null) {
+				return invalid(at, "expected a plain object");
+			}
+		}
+		if (Object.getOwnPropertySymbols(item).length) {
+			return invalid(at, "symbol properties are unsupported");
+		}
+		ancestors.add(item);
+		try {
+			if (Array.isArray(item)) {
+				return Array.from({ length: item.length }, function(_, index) {
+					var descriptor2 = Object.getOwnPropertyDescriptor(item, String(index));
+					if (!descriptor2 || !("value" in descriptor2)) {
+						return invalid(`${at}[${index}]`, "array holes and accessors are unsupported");
+					}
+					return visit(descriptor2.value, `${at}[${index}]`);
+				});
+			}
+			var result = /* @__PURE__ */ Object.create(null);
+			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+			try {
+				for (var _iterator = Object.keys(item).sort()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var key = _step.value;
+					var descriptor = Object.getOwnPropertyDescriptor(item, key);
+					var nextPath = `${at}[${JSON.stringify(key)}]`;
+					if (!("value" in descriptor)) return invalid(nextPath, "accessor is unsupported");
+					if (descriptor.value !== void 0) result[key] = visit(descriptor.value, nextPath);
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return != null) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
+			}
+			return result;
+		} finally {
+			ancestors.delete(item);
+		}
+	}
+	return visit(value, path);
+}
+function serializeProps(props) {
+	var prototype = Object.getPrototypeOf(props);
+	if (prototype !== Object.prototype && prototype !== null || Object.getOwnPropertySymbols(props).length) {
+		invalid("props", "expected plain props with string property names");
+	}
+	var data = /* @__PURE__ */ Object.create(null);
+	var actions = /* @__PURE__ */ new Map();
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = Object.keys(props).sort()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var name = _step.value;
+			var descriptor = Object.getOwnPropertyDescriptor(props, name);
+			if (!("value" in descriptor)) invalid(`props[${JSON.stringify(name)}]`, "accessor is unsupported");
+			var value = descriptor.value;
+			if (name === "children" && value !== void 0) {
+				invalid("props.children", "children cannot cross the DOM boundary");
+			}
+			if (typeof value === "function") actions.set(name, value);
+			else if (value !== void 0) data[name] = serializeData(value, `props[${JSON.stringify(name)}]`);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return {
+		props: data,
+		actions,
+		key: JSON.stringify([data, [...actions.keys()]])
+	};
+}
+function serializeError(error) {
+	var development = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+	var result = {
+		name: "Error",
+		message: "An unsupported error was thrown"
+	};
+	try {
+		if (error instanceof Error) {
+			result = {
+				name: String(error.name || "Error"),
+				message: String(error.message)
+			};
+			var code = error.code;
+			if (typeof code === "string") result.code = code;
+			if (development && typeof error.stack === "string") result.stack = error.stack;
+		} else if (error === null || [
+			"string",
+			"number",
+			"boolean",
+			"undefined",
+			"bigint"
+		].includes(typeof error)) {
+			result.message = String(error);
+		}
+	} catch (unused) {}
+	return result;
+}
+function deserializeError(error) {
+	var result = new DOMBridgeError(error.message, error.code || "DOM_REMOTE_ERROR");
+	result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	return result;
+}