@tstdl/base 0.87.13 → 0.88.0-alpha1

package/serializer/handlers/regex.js

@@ -1,33 +1,9 @@
-"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 regex_exports = {};
-__export(regex_exports, {
-  deserializeRegExp: () => deserializeRegExp,
-  serializeRegExp: () => serializeRegExp
-});
-module.exports = __toCommonJS(regex_exports);
-function serializeRegExp(regex) {
-  return {
-    pattern: regex.source,
-    flags: regex.flags
-  };
+export function serializeRegExp(regex) {
+    return {
+        pattern: regex.source,
+        flags: regex.flags
+    };
 }
-function deserializeRegExp(data) {
-  return new RegExp(data.pattern, data.flags);
+export function deserializeRegExp(data) {
+    return new RegExp(data.pattern, data.flags);
 }

package/serializer/handlers/register.js

@@ -1,61 +1,38 @@
-"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 register_exports = {};
-__export(register_exports, {
-  registerDefaultSerializers: () => registerDefaultSerializers
-});
-module.exports = __toCommonJS(register_exports);
-var import_supports = require("../../supports.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_binary = require("./binary.js");
-var import_date = require("./date.js");
-var import_error = require("./error.js");
-var import_map = require("./map.js");
-var import_regex = require("./regex.js");
-var import_set = require("./set.js");
+import { supportsBuffer } from '../../supports.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { deserializeArrayBuffer, deserializeBuffer, getTypedArrayDeserializer, serializeArrayBuffer, serializeBuffer, serializeTypedArray } from './binary.js';
+import { deserializeDate, serializeDate } from './date.js';
+import { deserializeError, serializeError } from './error.js';
+import { deserializeMap, serializeMap } from './map.js';
+import { deserializeRegExp, serializeRegExp } from './regex.js';
+import { deserializeSet, serializeSet } from './set.js';
 const typedArrays = [
-  globalThis.Int8Array,
-  globalThis.Uint8Array,
-  globalThis.Uint8ClampedArray,
-  globalThis.Int16Array,
-  globalThis.Uint16Array,
-  globalThis.Int32Array,
-  globalThis.Uint32Array,
-  globalThis.Float32Array,
-  globalThis.Float64Array,
-  globalThis.BigInt64Array,
-  globalThis.BigUint64Array
-].filter(import_type_guards.isDefined);
-function registerDefaultSerializers(register, registerRaw) {
-  register(Set, "Set", import_set.serializeSet, import_set.deserializeSet);
-  register(Map, "Map", import_map.serializeMap, import_map.deserializeMap);
-  register(RegExp, "RegExp", import_regex.serializeRegExp, import_regex.deserializeRegExp);
-  register(Date, "Date", import_date.serializeDate, import_date.deserializeDate);
-  register(Error, "Error", import_error.serializeError, import_error.deserializeError);
-  register(ArrayBuffer, "ArrayBuffer", import_binary.serializeArrayBuffer, import_binary.deserializeArrayBuffer);
-  for (const typedArray of typedArrays) {
-    register(typedArray, typedArray.name, import_binary.serializeTypedArray, (0, import_binary.getTypedArrayDeserializer)(typedArray));
-  }
-  if (import_supports.supportsBuffer) {
-    register(Buffer, "Buffer", import_binary.serializeBuffer, import_binary.deserializeBuffer);
-  }
-  if (typeof MessagePort != "undefined") {
-    registerRaw(MessagePort);
-  }
+    globalThis.Int8Array,
+    globalThis.Uint8Array,
+    globalThis.Uint8ClampedArray,
+    globalThis.Int16Array,
+    globalThis.Uint16Array,
+    globalThis.Int32Array,
+    globalThis.Uint32Array,
+    globalThis.Float32Array,
+    globalThis.Float64Array,
+    globalThis.BigInt64Array,
+    globalThis.BigUint64Array
+].filter(isDefined);
+export function registerDefaultSerializers(register, registerRaw) {
+    register(Set, 'Set', serializeSet, deserializeSet);
+    register(Map, 'Map', serializeMap, deserializeMap);
+    register(RegExp, 'RegExp', serializeRegExp, deserializeRegExp);
+    register(Date, 'Date', serializeDate, deserializeDate);
+    register(Error, 'Error', serializeError, deserializeError);
+    register(ArrayBuffer, 'ArrayBuffer', serializeArrayBuffer, deserializeArrayBuffer);
+    for (const typedArray of typedArrays) {
+        register(typedArray, typedArray.name, serializeTypedArray, getTypedArrayDeserializer(typedArray));
+    }
+    if (supportsBuffer) {
+        register(Buffer, 'Buffer', serializeBuffer, deserializeBuffer);
+    }
+    if (typeof MessagePort != 'undefined') {
+        registerRaw(MessagePort);
+    }
 }

package/serializer/handlers/set.js

@@ -1,40 +1,16 @@
-"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 set_exports = {};
-__export(set_exports, {
-  deserializeSet: () => deserializeSet,
-  serializeSet: () => serializeSet
-});
-module.exports = __toCommonJS(set_exports);
-function serializeSet(set) {
-  const data = [...set.values()];
-  return data;
+export function serializeSet(set) {
+    const data = [...set.values()];
+    return data;
 }
-function deserializeSet(data, tryDereference) {
-  const set = /* @__PURE__ */ new Set();
-  for (const item of data) {
-    const has = tryDereference(item, (dereferenced) => {
-      set.add(dereferenced);
-    });
-    if (!has) {
-      set.add(item);
+export function deserializeSet(data, tryDereference) {
+    const set = new Set();
+    for (const item of data) {
+        const has = tryDereference(item, (dereferenced) => {
+            set.add(dereferenced);
+        });
+        if (!has) {
+            set.add(item);
+        }
     }
-  }
-  return set;
+    return set;
 }

package/serializer/index.js

@@ -1,30 +1,3 @@
-"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var serializer_exports = {};
-__export(serializer_exports, {
-  Serializable: () => import_serializable.Serializable,
-  registerSerializable: () => import_serializable.registerSerializable,
-  registerSerializer: () => import_serializable.registerSerializer,
-  serializable: () => import_serializable.serializable
-});
-module.exports = __toCommonJS(serializer_exports);
-var import_serializable = require("./serializable.js");
-__reExport(serializer_exports, require("./serializer.js"), module.exports);
-__reExport(serializer_exports, require("./types.js"), module.exports);
+export { registerSerializable, registerSerializer, Serializable, serializable } from './serializable.js';
+export * from './serializer.js';
+export * from './types.js';

package/serializer/serializable.js

@@ -1,76 +1,51 @@
-"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 });
+import { isDefined, isFunction } from '../utils/type-guards.js';
+import { registerDefaultSerializers } from './handlers/register.js';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const Serializable = {
+    serialize: Symbol('serialize'),
+    deserialize: Symbol('deserialize')
 };
-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 serializable_exports = {};
-__export(serializable_exports, {
-  Serializable: () => Serializable,
-  getSerializerByTypeName: () => getSerializerByTypeName,
-  getTypeNameByConstructor: () => getTypeNameByConstructor,
-  isRawSerializable: () => isRawSerializable,
-  registerRawSerializable: () => registerRawSerializable,
-  registerSerializable: () => registerSerializable,
-  registerSerializer: () => registerSerializer,
-  serializable: () => serializable
-});
-module.exports = __toCommonJS(serializable_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_register = require("./handlers/register.js");
-const Serializable = {
-  serialize: Symbol("serialize"),
-  deserialize: Symbol("deserialize")
-};
-const constructorTypeNameMap = /* @__PURE__ */ new Map();
-const typeNameSerializerMap = /* @__PURE__ */ new Map();
-const rawSet = /* @__PURE__ */ new Set();
-function getTypeNameByConstructor(constructor) {
-  return constructorTypeNameMap.get(constructor);
+const constructorTypeNameMap = new Map();
+const typeNameSerializerMap = new Map();
+const rawSet = new Set();
+export function getTypeNameByConstructor(constructor) {
+    return constructorTypeNameMap.get(constructor);
 }
-function getSerializerByTypeName(typeName) {
-  return typeNameSerializerMap.get(typeName);
+export function getSerializerByTypeName(typeName) {
+    return typeNameSerializerMap.get(typeName);
 }
-function registerRawSerializable(constructor) {
-  rawSet.add(constructor);
+export function registerRawSerializable(constructor) {
+    rawSet.add(constructor);
 }
-function isRawSerializable(constructor) {
-  return rawSet.has(constructor);
+export function isRawSerializable(constructor) {
+    return rawSet.has(constructor);
 }
-function serializable(typeName) {
-  function serializableDecorator(type) {
-    registerSerializable(type, typeName);
-  }
-  return serializableDecorator;
+export function serializable(typeName) {
+    function serializableDecorator(type) {
+        registerSerializable(type, typeName);
+    }
+    return serializableDecorator;
 }
-function registerSerializable(type, typeName) {
-  const { [Serializable.serialize]: serializer, [Serializable.deserialize]: deserializer } = type.prototype;
-  if (!(0, import_type_guards.isFunction)(serializer) || !(0, import_type_guards.isFunction)(deserializer)) {
-    throw new Error("implementation for at least one of [type], [serialize] and [deserialize] is missing or of wrong type");
-  }
-  registerSerializer(type, typeName ?? type.name, serializer, deserializer);
+/**
+ * register a serializable type for serialization
+ * @param type class implementing {@link Serializable}
+ */
+export function registerSerializable(type, typeName) {
+    const { [Serializable.serialize]: serializer, [Serializable.deserialize]: deserializer } = type.prototype;
+    if (!isFunction(serializer) || !isFunction(deserializer)) {
+        throw new Error('implementation for at least one of [type], [serialize] and [deserialize] is missing or of wrong type');
+    }
+    registerSerializer(type, typeName ?? type.name, serializer, deserializer);
 }
-function registerSerializer(constructor, typeName, serializer, deserializer, options) {
-  const existingMappedType = constructorTypeNameMap.get(constructor);
-  const existingMappedSerializer = typeNameSerializerMap.get(typeName);
-  if ((0, import_type_guards.isDefined)(existingMappedType) || (0, import_type_guards.isDefined)(existingMappedSerializer)) {
-    const ctor = existingMappedSerializer?.constructor ?? constructor;
-    throw new Error(`serializer for constructor ${ctor.name} is already registered as ${existingMappedType ?? typeName}`);
-  }
-  const registration = { ...options, type: typeName, constructor, serializer, deserializer };
-  constructorTypeNameMap.set(constructor, typeName);
-  typeNameSerializerMap.set(typeName, registration);
+export function registerSerializer(constructor, typeName, serializer, deserializer, options) {
+    const existingMappedType = constructorTypeNameMap.get(constructor);
+    const existingMappedSerializer = typeNameSerializerMap.get(typeName);
+    if (isDefined(existingMappedType) || isDefined(existingMappedSerializer)) {
+        const ctor = existingMappedSerializer?.constructor ?? constructor;
+        throw new Error(`serializer for constructor ${ctor.name} is already registered as ${existingMappedType ?? typeName}`);
+    }
+    const registration = { ...options, type: typeName, constructor, serializer, deserializer };
+    constructorTypeNameMap.set(constructor, typeName);
+    typeNameSerializerMap.set(typeName, registration);
 }
-(0, import_register.registerDefaultSerializers)(registerSerializer, registerRawSerializable);
+registerDefaultSerializers(registerSerializer, registerRawSerializable);