From 78261b5384fc3d462f3b50ce3444d7456108a805 Mon Sep 17 00:00:00 2001 From: rowan Date: Tue, 20 May 2025 02:25:28 -0500 Subject: [PATCH] wip classes --- dist/index.js | 1195 +++++++++++++++++++++++++++++++++++++++++ dist/test.js | 1409 +++++++++++++++++++++++++++++++++++++++++++++++++ src/de.ts | 35 +- src/index.ts | 2 +- src/ser.ts | 34 +- 5 files changed, 2671 insertions(+), 4 deletions(-) create mode 100644 dist/index.js create mode 100644 dist/test.js diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..223094b --- /dev/null +++ b/dist/index.js @@ -0,0 +1,1195 @@ +"use strict"; +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + 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 + )); + + // ../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js + var require_lib = __commonJS({ + "../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + Symbol.metadata ??= Symbol("Symbol.metadata"); + } + }); + + // ../serde-ts/dist/utils.js + var require_utils = __commonJS({ + "../serde-ts/dist/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.staticImplements = staticImplements; + exports.isPlainObject = isPlainObject; + exports.isFunction = isFunction; + exports.isIterable = isIterable; + exports.isString = isString; + exports.isNumber = isNumber; + exports.orElse = orElse; + exports.ifNull = ifNull; + exports.mixin = mixin2; + exports.pipe = pipe; + function staticImplements() { + return (constructor) => { + constructor; + }; + } + function isPlainObject(value) { + return Object.getPrototypeOf(value) === Object.prototype; + } + function isFunction(value) { + return value != null && typeof value === "function"; + } + function isIterable(value) { + return isFunction(value[Symbol.iterator]); + } + function isString(value) { + return typeof value === "string"; + } + function isNumber(value) { + return !isNaN(value); + } + function orElse(thisArg, a, b2) { + return function(...args) { + const fn = a != null ? a : b2; + return fn.apply(thisArg, args); + }; + } + function ifNull(thisArg, b2, ...args) { + return function(a) { + return orElse(thisArg, a, b2).apply(thisArg, args); + }; + } + function applyMixins(derivedCtor, constructors) { + constructors.forEach((baseCtor) => { + Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => { + Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)); + }); + }); + } + function mixin2(impl) { + return function(constructor) { + applyMixins(constructor, [impl]); + return constructor; + }; + } + function pipe(arg, firstFn, ...fns) { + return fns.reduce((acc, fn) => fn(acc), firstFn(arg)); + } + } + }); + + // ../serde-ts/dist/ser/interface.js + var require_interface = __commonJS({ + "../serde-ts/dist/ser/interface.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isGenericSerializer = isGenericSerializer; + var utils_1 = require_utils(); + var TypeSerializerMethods = [ + "serializeString", + "serializeNumber", + "serializeBigInt", + "serializeBoolean", + "serializeSymbol", + //'serializeMap', + "serializeIterable", + "serializeNull", + "serializeObject", + "serializeClass" + ]; + var AnySerializerMethods = ["serializeAny"]; + function isGenericSerializer(value) { + return AnySerializerMethods.every((k) => (0, utils_1.isFunction)(value[k])) && TypeSerializerMethods.every((k) => !(0, utils_1.isFunction)(value[k])); + } + } + }); + + // ../serde-ts/dist/case.js + var require_case = __commonJS({ + "../serde-ts/dist/case.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CaseConvention = void 0; + exports.convertCase = convertCase; + exports.CaseConvention = Object.freeze({ + Lowercase: 0, + Uppercase: 1, + PascalCase: 2, + CamelCase: 3, + SnakeCase: 4, + ScreamingSnakeCase: 5, + KebabCase: 6, + ScreamingKebabCase: 7 + }); + var wordBoundaryRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g; + function identifyWords(value) { + return value && value.match(wordBoundaryRegex); + } + var lower = (ch) => ch.toLowerCase(); + var upper = (ch) => ch.toUpperCase(); + var first = (xs) => xs && xs[0]; + var tail = (xs) => xs && xs.slice(1); + function upperFirst(xs) { + return upper(first(xs)) + tail(xs); + } + function toPascalCase(words) { + return words.map(lower).map(upperFirst).join(""); + } + var joinMap = (fn, delim, xs) => { + return xs.map(fn).join(delim); + }; + function convertCase(value, convention) { + const words = identifyWords(value); + if (!words || words.length <= 0) { + return ""; + } + switch (convention) { + case exports.CaseConvention.Lowercase: + return words.join("").toLowerCase(); + case exports.CaseConvention.Uppercase: + return words.join("").toUpperCase(); + case exports.CaseConvention.PascalCase: + return toPascalCase(words); + case exports.CaseConvention.CamelCase: + const pascal = toPascalCase(words); + return first(pascal).toLowerCase() + tail(pascal); + case exports.CaseConvention.SnakeCase: + return joinMap(lower, "_", words); + case exports.CaseConvention.ScreamingSnakeCase: + return joinMap(upper, "_", words); + case exports.CaseConvention.KebabCase: + return joinMap(lower, "-", words); + case exports.CaseConvention.ScreamingKebabCase: + return joinMap(upper, "-", words); + } + } + } + }); + + // ../serde-ts/dist/registry.js + var require_registry = __commonJS({ + "../serde-ts/dist/registry.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.GlobalRegistry = exports.Registry = void 0; + var Registry = class { + constructor() { + Object.defineProperty(this, "registeredClasses", { + enumerable: true, + configurable: true, + writable: true, + value: /* @__PURE__ */ new Map() + }); + } + add(ctor, key = ctor.name) { + this.registeredClasses.set(key, ctor); + } + get(name) { + return this.registeredClasses.get(name); + } + }; + exports.Registry = Registry; + exports.GlobalRegistry = new Registry(); + } + }); + + // ../serde-ts/dist/options.js + var require_options = __commonJS({ + "../serde-ts/dist/options.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SerdeOptions = exports.Stage = void 0; + var case_1 = require_case(); + var utils_1 = require_utils(); + var registry_1 = require_registry(); + exports.Stage = Object.freeze({ + Serialize: 0, + Deserialize: 1 + }); + var SerdeOptions = class { + get registry() { + return this.options.registry || registry_1.GlobalRegistry; + } + constructor(options = {}, properties = /* @__PURE__ */ new Map()) { + Object.defineProperty(this, "target", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "properties", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.options = options; + this.properties = properties; + } + static from(target) { + return new this(target); + } + getClassName(stage) { + var _a, _b; + if ((0, utils_1.isString)(this.options.rename)) { + return this.options.rename; + } else if (stage === exports.Stage.Serialize && (0, utils_1.isString)((_a = this.options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) { + return this.options.rename.serialize; + } else if (stage === exports.Stage.Deserialize && (0, utils_1.isString)((_b = this.options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return this.options.rename.deserialize; + } else { + return this.target.constructor.name; + } + } + getPropertyRename(property, stage, options) { + var _a, _b; + if (options != null) { + if ((0, utils_1.isString)(options.rename)) { + return options.rename; + } else if (stage === exports.Stage.Serialize && (0, utils_1.isString)((_a = options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) { + return options.rename.serialize; + } else if (stage === exports.Stage.Deserialize && (0, utils_1.isString)((_b = options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return options.rename.deserialize; + } + } + return property; + } + getPropertyCase(name, stage) { + var _a, _b; + if ((0, utils_1.isNumber)(this.options.renameAll)) { + return (0, case_1.convertCase)(name, this.options.renameAll); + } else if (stage === exports.Stage.Serialize && (0, utils_1.isNumber)((_a = this.options.renameAll) === null || _a === void 0 ? void 0 : _a.serialize)) { + return (0, case_1.convertCase)(name, this.options.renameAll.serialize); + } else if (stage === exports.Stage.Deserialize && (0, utils_1.isNumber)((_b = this.options.renameAll) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return (0, case_1.convertCase)(name, this.options.renameAll.deserialize); + } else { + return name; + } + } + getPropertyName(property, stage) { + const options = this.properties.get(property); + const name = options != null ? this.getPropertyRename(property, stage, options) : property; + return this.getPropertyCase(name, stage); + } + getSerializationName(property) { + return this.getPropertyName(property, exports.Stage.Serialize); + } + getDeserializationName(property) { + return this.getPropertyName(property, exports.Stage.Deserialize); + } + getDefault(property) { + const options = this.properties.get(property); + if (options && (0, utils_1.isFunction)(options.default)) { + return options.default(); + } else if ((0, utils_1.isFunction)(this.options.default)) { + return this.options.default(); + } + } + //getCustomImpl(property: string, stage: Stage) { + // const options = this.properties.get(property) + // if (options != null) { + // if (stage === Stage.Serialize && isFunction(options.serializeWith)) { + // return options.serializeWith + // } else if (stage === Stage.Deserialize && isFunction(options.deserializeWith)) { + // return options.deserializeWith + // } + // } + //} + //getSerializer(property: string): Nullable { + // return this.getCustomImpl(property, Stage.Serialize) as CustomSerializer + //} + //getDeserializer(property: string): Nullable { + // return this.getCustomImpl(property, Stage.Deserialize) as CustomDeserializer + //} + isConditionalSkip(skip) { + return "if" in skip && (0, utils_1.isFunction)(skip.if); + } + shouldSkip(property, value, stage) { + const options = this.properties.get(property); + if (options != null && options.skip != null) { + if (typeof options.skip === "boolean") { + return options.skip; + } else if (this.isConditionalSkip(options.skip)) { + return options.skip.if(value); + } else if (stage === exports.Stage.Serialize && typeof options.skip.serializing === "boolean") { + return options.skip.serializing; + } else if (stage === exports.Stage.Serialize && this.isConditionalSkip(options.skip.serializing)) { + return options.skip.serializing.if(value); + } else if (stage === exports.Stage.Deserialize && typeof options.skip.deserializing === "boolean") { + return options.skip.deserializing; + } else if (stage === exports.Stage.Deserialize && this.isConditionalSkip(options.skip.deserializing)) { + return options.skip.deserializing.if(value); + } + } + return false; + } + shouldSkipSerializing(property, value) { + return this.shouldSkip(property, value, exports.Stage.Serialize); + } + shouldSkipDeserializing(property, value) { + return this.shouldSkip(property, value, exports.Stage.Deserialize); + } + }; + exports.SerdeOptions = SerdeOptions; + } + }); + + // ../serde-ts/dist/ser/impl.js + var require_impl = __commonJS({ + "../serde-ts/dist/ser/impl.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serializeWith = serializeWith3; + var options_1 = require_options(); + var utils_1 = require_utils(); + var unhandledType = (serializer, value) => new TypeError(`'${serializer.constructor.name}' has no method for value type '${typeof value}'`); + function serializeEntries(serializer, value, options) { + var _a; + let state; + for (const [key, val] of value) { + if (options === null || options === void 0 ? void 0 : options.shouldSkipSerializing(key, val)) { + continue; + } + const name = (_a = options === null || options === void 0 ? void 0 : options.getPropertyName(key, options_1.Stage.Serialize)) !== null && _a !== void 0 ? _a : key; + state = serializer.serializeKey(name); + state = serializer.serializeValue(val); + } + return serializer.end(); + } + function serializeObject(serializer, value, options) { + const ser = serializer.serializeClass(value.constructor.name); + return serializeEntries(ser, Object.entries(value), options); + } + function serializeIter(serializer, value, options) { + let state; + for (const val of value) { + state = serializer.serializeElement(val); + } + return serializer.end(); + } + function defaultOptions(value) { + return value.constructor[Symbol.metadata].serde; + } + function serializeWith3(serializer, value, optionsGetter = defaultOptions) { + const serializeAny = (0, utils_1.orElse)(serializer, serializer.serializeAny, (value2) => unhandledType(serializer, value2)); + const serialize = (0, utils_1.ifNull)(serializer, serializeAny, value); + switch (typeof value) { + case "string": + return serialize(serializer.serializeString); + case "number": + return serialize(serializer.serializeNumber); + case "bigint": + return serialize(serializer.serializeBigInt); + case "boolean": + return serialize(serializer.serializeBoolean); + case "symbol": + return serialize(serializer.serializeSymbol); + case "undefined": + return serialize(serializer.serializeNull); + case "object": + const options = optionsGetter(value); + if ((0, utils_1.isIterable)(value) && (0, utils_1.isFunction)(serializer.serializeIterable)) { + return serializeIter(serializer.serializeIterable(), value, options); + } else if ((0, utils_1.isFunction)(serializer.serializeObject)) { + return serializeObject(serializer, value, options); + } + // deliberate fallthrough when the above fail + default: + return serializeAny(value); + } + } + } + }); + + // ../serde-ts/dist/ser/mixin.js + var require_mixin = __commonJS({ + "../serde-ts/dist/ser/mixin.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serialize = serialize; + var impl_1 = require_impl(); + var interface_1 = require_interface(); + function serialize(constructor) { + class Serializable2 extends constructor { + serialize(serializer) { + if ((0, interface_1.isGenericSerializer)(serializer)) { + return serializer.serializeAny(this); + } else { + return (0, impl_1.serializeWith)(serializer, this); + } + } + } + Object.defineProperty(Serializable2, "name", { + enumerable: true, + configurable: true, + writable: true, + value: constructor.name + }); + return Serializable2; + } + } + }); + + // ../serde-ts/dist/ser/index.js + var require_ser = __commonJS({ + "../serde-ts/dist/ser/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + require_lib(); + __exportStar(require_interface(), exports); + __exportStar(require_mixin(), exports); + __exportStar(require_impl(), exports); + } + }); + + // ../serde-ts/dist/de/generic.js + var require_generic = __commonJS({ + "../serde-ts/dist/de/generic.js"(exports) { + "use strict"; + var __esDecorate = exports && exports.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { + if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); + return f; + } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function(f) { + if (done) throw new TypeError("Cannot add initializers after decoration has completed"); + extraInitializers.push(accept(f || null)); + }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + }; + var __runInitializers = exports && exports.__runInitializers || function(thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + }; + var __setFunctionName = exports && exports.__setFunctionName || function(f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.GenericVisitor = exports.GenericSeed = void 0; + var utils_1 = require_utils(); + var GenericSeed = (() => { + let _classDecorators = [(0, utils_1.staticImplements)()]; + let _classDescriptor; + let _classExtraInitializers = []; + let _classThis; + var GenericSeed2 = _classThis = class { + static deserialize(deserializer) { + return deserializer.deserializeAny(new GenericVisitor2()); + } + deserialize(deserializer) { + return GenericSeed2.deserialize(deserializer); + } + }; + __setFunctionName(_classThis, "GenericSeed"); + (() => { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0; + __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers); + GenericSeed2 = _classThis = _classDescriptor.value; + if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + __runInitializers(_classThis, _classExtraInitializers); + })(); + return GenericSeed2 = _classThis; + })(); + exports.GenericSeed = GenericSeed; + var GenericVisitor2 = class { + visitString(value) { + return value; + } + visitNumber(value) { + return value; + } + visitBigInt(value) { + return value; + } + visitBoolean(value) { + return value; + } + visitSymbol(value) { + return value; + } + visitNull() { + return null; + } + visitObject(access) { + const result = {}; + let entry; + while (entry = access.nextEntry()) { + result[entry[0]] = entry[1]; + } + return result; + } + visitIterable(access) { + const result = new Array(access.sizeHint()); + let element; + while (element = access.nextElement()) { + result.push(element); + } + return result; + } + }; + exports.GenericVisitor = GenericVisitor2; + } + }); + + // ../serde-ts/dist/de/interface.js + var require_interface2 = __commonJS({ + "../serde-ts/dist/de/interface.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DefaultIterableAccessImpl = exports.DefaultMapAccessImpl = void 0; + var generic_1 = require_generic(); + var DefaultMapAccessImpl2 = class { + nextEntrySeed(kseed, vseed) { + const key = this.nextKeySeed(kseed); + if (key !== void 0) { + const value = this.nextValueSeed(vseed); + if (value !== void 0) { + return [key, value]; + } + } + } + nextKey() { + return this.nextValueSeed(generic_1.GenericSeed); + } + nextValue() { + return this.nextValueSeed(generic_1.GenericSeed); + } + nextEntry() { + return this.nextEntrySeed(generic_1.GenericSeed, generic_1.GenericSeed); + } + }; + exports.DefaultMapAccessImpl = DefaultMapAccessImpl2; + var DefaultIterableAccessImpl2 = class { + nextElement() { + return this.nextElementSeed(generic_1.GenericSeed); + } + sizeHint() { + return 0; + } + }; + exports.DefaultIterableAccessImpl = DefaultIterableAccessImpl2; + } + }); + + // ../serde-ts/dist/de/impl.js + var require_impl2 = __commonJS({ + "../serde-ts/dist/de/impl.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserializeWith = deserializeWith; + var options_1 = require_options(); + var generic_1 = require_generic(); + function deserializeWith(deserializer, into, options) { + const visitor = new generic_1.GenericVisitor(); + const target = new into(); + const obj = deserializer.deserializeObject(visitor); + const newObject = {}; + for (const property in target) { + const name = options.getPropertyName(property, options_1.Stage.Deserialize); + const value = obj[name] || options.getDefault(property); + newObject[property] = value; + delete obj[name]; + } + if (options.options.denyUnknownFields && Object.keys(obj).length > 0) { + throw new TypeError(`Unexpected fields: ${Object.keys(obj).join(", ")}`); + } + return Object.assign(target, newObject); + } + } + }); + + // ../serde-ts/dist/de/mixin.js + var require_mixin2 = __commonJS({ + "../serde-ts/dist/de/mixin.js"(exports) { + "use strict"; + var __esDecorate = exports && exports.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { + if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); + return f; + } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function(f) { + if (done) throw new TypeError("Cannot add initializers after decoration has completed"); + extraInitializers.push(accept(f || null)); + }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + }; + var __runInitializers = exports && exports.__runInitializers || function(thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + }; + var __setFunctionName = exports && exports.__setFunctionName || function(f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserialize = deserialize; + var utils_1 = require_utils(); + var impl_1 = require_impl2(); + function deserialize(constructor) { + let Deserializable = (() => { + let _classDecorators = [(0, utils_1.staticImplements)()]; + let _classDescriptor; + let _classExtraInitializers = []; + let _classThis; + let _classSuper = constructor; + var Deserializable2 = _classThis = class extends _classSuper { + static deserialize(deserializer) { + return (0, impl_1.deserializeWith)(deserializer, this, this[Symbol.metadata].serde); + } + }; + __setFunctionName(_classThis, "Deserializable"); + (() => { + var _a; + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0; + __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers); + Deserializable2 = _classThis = _classDescriptor.value; + if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + })(); + Object.defineProperty(_classThis, "name", { + enumerable: true, + configurable: true, + writable: true, + value: constructor.name + }); + (() => { + __runInitializers(_classThis, _classExtraInitializers); + })(); + return Deserializable2 = _classThis; + })(); + return Deserializable; + } + } + }); + + // ../serde-ts/dist/de/index.js + var require_de = __commonJS({ + "../serde-ts/dist/de/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar(require_interface2(), exports); + __exportStar(require_generic(), exports); + __exportStar(require_mixin2(), exports); + } + }); + + // src/index.ts + var import_ser2 = __toESM(require_ser()); + + // src/ser.ts + var import_ser = __toESM(require_ser()); + var JSONObjectSerializer = class { + ser; + first = true; + constructor(serializer) { + this.ser = serializer; + serializer.write("{"); + } + serializeKey(key) { + if (!this.first) { + this.ser.write(","); + } else { + this.first = false; + } + (0, import_ser.serializeWith)(this.ser, key); + this.ser.write(":"); + } + serializeValue(value) { + (0, import_ser.serializeWith)(this.ser, value); + } + end() { + this.ser.write("}"); + } + }; + var JSONIterableSerializer = class { + ser; + first = true; + constructor(serializer) { + this.ser = serializer; + serializer.write("["); + } + serializeElement(element) { + if (!this.first) { + this.ser.write(","); + } else { + this.first = false; + } + (0, import_ser.serializeWith)(this.ser, element); + } + end() { + this.ser.write("]"); + } + }; + var JSONClassSerializer = class { + outer; + inner; + constructor(serializer, name) { + this.outer = new JSONObjectSerializer(serializer); + this.serializeKey("type"); + this.serializeValue(name); + this.serializeKey("object"); + console.log("what the fuckkkkkkkkk"); + this.inner = new JSONObjectSerializer(serializer); + console.log(this.inner); + } + serializeKey(key) { + console.log(this.inner); + return this.inner.serializeKey(key); + } + serializeValue(value) { + return this.inner.serializeValue(value); + } + end() { + this.inner.end(); + this.outer.end(); + } + }; + var JSONSerializer = class { + output = ""; + write(value) { + this.output += value; + } + serializeString(value) { + this.write(`"${value}"`); + } + serializeBoolean(value) { + this.write(value.toString()); + } + serializeSymbol(value) { + const key = Symbol.keyFor(value); + if (key) { + this.write(key); + } else { + return this.serializeString(value.toString()); + } + } + serializeObject() { + return new JSONObjectSerializer(this); + } + serializeClass(name) { + return new JSONClassSerializer(this, name); + } + serializeNumber(value) { + this.write(value.toString()); + } + serializeBigInt(value) { + this.write(value.toString()); + } + serializeIterable() { + return new JSONIterableSerializer(this); + } + serializeNull() { + return this.write("null"); + } + }; + + // src/de.ts + var import_de = __toESM(require_de()); + var import_utils = __toESM(require_utils()); + + // src/err.ts + var unexpected = (expected, actual, position) => new SyntaxError(`Expected ${expected} at position ${position} (got '${actual}')`); + + // src/de.ts + var clamp = (value, min, max) => { + return Math.min(Math.max(value, min), max); + }; + var isNumeric = (value) => { + return !isNaN(value); + }; + var isNumericToken = (value) => { + return value === Token.Period || value === Token.Hyphen || Token.Digit.includes(value); + }; + var encoder = new TextEncoder(); + var b = (strings) => encoder.encode(strings[0]); + var char = (strings) => b(strings)[0]; + var Literal = Object.freeze({ + True: b`true`, + False: b`false` + }); + var Token = Object.freeze({ + Space: char` `, + LeftCurly: char`{`, + RightCurly: char`}`, + LeftSquare: char`[`, + RightSquare: char`]`, + Quote: char`"`, + ForwardSlash: char`\\`, + Digit: b`0123456789`, + Hyphen: char`-`, + Period: char`.`, + Comma: char`,`, + Colon: char`:` + }); + var CommaSeparated = @((0, import_utils.mixin)(import_de.DefaultMapAccessImpl)) @((0, import_utils.mixin)(import_de.DefaultIterableAccessImpl)) class { + de; + first = true; + constructor(deserializer) { + this.de = deserializer; + } + nextKeySeed(seed) { + if (this.de.buffer.peek().next() === Token.RightCurly) { + return; + } + if (!this.first) { + const take = this.de.buffer.take(); + if (take.next() !== Token.Comma) { + throw unexpected(",", take.toString(), this.de.buffer.position); + } + } + this.first = false; + return seed.deserialize(this.de); + } + nextValueSeed(seed) { + const next = this.de.buffer.next(); + if (next !== Token.Colon) { + console.log(this.de.buffer.toString()); + throw unexpected(":", next.toString(), this.de.buffer.position); + } + return seed.deserialize(this.de); + } + nextElementSeed(seed) { + if (this.de.buffer.peek().next() === Token.RightSquare) { + return; + } + if (!this.first) { + const take = this.de.buffer.take(); + if (take.next() !== Token.Comma) { + throw unexpected(",", take.toString(), this.de.buffer.position); + } + } + this.first = false; + return seed.deserialize(this.de); + } + }; + var StringBuffer = class _StringBuffer { + view; + index = 0; + encoder; + decoder; + get position() { + return this.index; + } + get length() { + return this.view.byteLength; + } + constructor(view, encoder2 = new TextEncoder(), decoder = new TextDecoder()) { + this.view = view; + this.encoder = encoder2; + this.decoder = decoder; + } + static fromArrayBuffer(value, encoder2, decoder) { + return new this(new Uint8Array(value), encoder2, decoder); + } + static fromString(value, encoder2 = new TextEncoder(), decoder) { + return this.fromArrayBuffer( + encoder2.encode(value), + encoder2, + decoder + ); + } + next() { + const value = this.view[this.index]; + this.index += 1; + return value; + } + nextChar() { + return this.take().toString(); + } + done() { + return this.index >= this.view.byteLength; + } + toBytes() { + return this.view.slice(this.index); + } + toString() { + return this.decoder.decode(this.toBytes()); + } + take(limit = 1) { + const bytes = this.peek(limit); + this.index += limit; + return bytes; + } + at(index) { + return this.view[this.index + index]; + } + takeWhile(fn) { + let index = 0; + while (!this.done() && fn(this.at(index))) { + index += 1; + } + return this.take(index); + } + drop(limit) { + this.index += limit; + return this; + } + peek(limit = 1) { + const index = this.index; + return this.slice(index, index + limit); + } + startsWith(value) { + if (typeof value === "string") { + return this.startsWith(this.encoder.encode(value)); + } + const length = value.byteLength; + const bytes = new Uint8Array(value); + return this.peek(length).toBytes().every((v, i) => v === bytes[i]); + } + slice(start, end) { + return new _StringBuffer( + this.view.subarray(start, end), + this.encoder, + this.decoder + ); + } + indexOf(value, start = 0) { + const search = new Uint8Array(isNumeric(value) ? [value] : value); + start = clamp(start, this.index, this.length); + const bytes = this.slice(start); + for (let i = 0, len = bytes.length; i < len; i++) { + if (bytes.at(i) === search[0] && bytes.slice(i).startsWith(search)) { + return i; + } + } + return -1; + } + }; + var JSONDeserializer = class { + buffer; + constructor(buffer) { + this.buffer = buffer; + } + static fromString(value) { + return new this(StringBuffer.fromString(value)); + } + deserializeAny(visitor) { + const peek = this.buffer.peek(); + const nextByte = peek.take(); + const byte = nextByte.next(); + switch (true) { + case b`n`.includes(byte): + return this.deserializeNull(visitor); + case b`tf`.includes(byte): + return this.deserializeBoolean(visitor); + case b`-0123456789`.includes(byte): + return this.deserializeNumber(visitor); + case Token.Quote === byte: + return this.deserializeString(visitor); + case Token.LeftSquare === byte: + return this.deserializeIterable(visitor); + case Token.LeftCurly === byte: + return this.deserializeObject(visitor); + default: + throw new SyntaxError(`Invalid syntax at position ${this.buffer.position}: "${nextByte.toString()}"`); + } + } + deserializeNull(visitor) { + if (this.buffer.startsWith("null")) { + this.buffer.take(4); + } + return visitor.visitNull(); + } + _deserializeObject(fn) { + let next = this.buffer.take(); + if (next.next() === Token.LeftCurly) { + const value = fn(new CommaSeparated(this)); + next = this.buffer.take(); + if (next.next() === Token.RightCurly) { + return value; + } else { + throw unexpected("}", next.toString(), this.buffer.position); + } + } else { + throw unexpected("{", next.toString(), this.buffer.position); + } + } + deserializeObject(visitor) { + return this._deserializeObject(visitor.visitObject.bind(visitor)); + } + deserializeString(visitor) { + const next = this.buffer.take(); + if (next.next() === Token.Quote) { + let index = -1; + do { + index = this.buffer.indexOf(Token.Quote, index); + } while (index > -1 && this.buffer.at(index - 1) === Token.ForwardSlash); + if (index === -1) { + throw new SyntaxError("Unterminated string literal"); + } + const bytes = this.buffer.take(index); + this.buffer.take(); + return visitor.visitString(bytes.toString()); + } else { + throw unexpected('"', next.toString(), this.buffer.position); + } + } + deserializeNumber(visitor) { + const next = this.buffer.peek().next(); + if (isNumericToken(next)) { + const digits = this.buffer.takeWhile(isNumericToken).toString(); + if (digits.length >= 16) { + const number = BigInt(digits); + return visitor.visitBigInt(number); + } else if (digits.length > 0) { + let number = parseInt(digits.toString(), 10); + return visitor.visitNumber(number); + } + } + throw unexpected('"-", ".", or 0..=9', next.toString(), this.buffer.position); + } + deserializeBigInt(visitor) { + return this.deserializeNumber(visitor); + } + deserializeBoolean(visitor) { + const next = this.buffer.next(); + let length = 3; + switch (next) { + case Literal.False[0]: + length = 4; + case Literal.True[0]: + break; + default: + throw unexpected('"true" or "false"', this.buffer.next().toString(), this.buffer.position); + } + this.buffer.take(length); + return visitor.visitBoolean(length === 3); + } + deserializeSymbol(_visitor) { + throw new Error("Method not implemented."); + } + deserializeIterable(visitor) { + let next = this.buffer.take(); + if (next.next() === Token.LeftSquare) { + const value = visitor.visitIterable(new CommaSeparated(this)); + next = this.buffer.take(); + if (next.next() === Token.RightSquare) { + return value; + } else { + throw unexpected("]", next.toString(), this.buffer.position); + } + } else { + throw unexpected("[", next.toString(), this.buffer.position); + } + } + }; + + // src/index.ts + function toString(value) { + const serializer = new JSONSerializer(); + (0, import_ser2.serializeWith)(serializer, value); + return serializer.output; + } + function fromString(value, into) { + const deserializer = JSONDeserializer.fromString(value); + return into.deserialize(deserializer); + } +})(); diff --git a/dist/test.js b/dist/test.js new file mode 100644 index 0000000..d7f02b9 --- /dev/null +++ b/dist/test.js @@ -0,0 +1,1409 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name); +var __typeError = (msg) => { + throw TypeError(msg); +}; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +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 __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)]; +var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"]; +var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn; +var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) }); +var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]); +var __runInitializers = (array, flags, self, value) => { + for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value); + return value; +}; +var __decorateElement = (array, flags, name, decorators, target, extra) => { + var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16); + var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5]; + var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []); + var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() { + return __privateGet(this, extra); + }, set [name](x) { + return __privateSet(this, extra, x); + } }, name)); + k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name); + for (var i = decorators.length - 1; i >= 0; i--) { + ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers); + if (k) { + ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x }; + if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name]; + if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y; + } + it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1; + if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it); + else if (typeof it !== "object" || it === null) __typeError("Object expected"); + else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn); + } + return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target; +}; +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); +var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); +var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj); +var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value); +var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method); + +// ../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js +var require_lib = __commonJS({ + "../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + Symbol.metadata ??= Symbol("Symbol.metadata"); + } +}); + +// ../serde-ts/dist/utils.js +var require_utils = __commonJS({ + "../serde-ts/dist/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.staticImplements = staticImplements; + exports2.isPlainObject = isPlainObject; + exports2.isFunction = isFunction; + exports2.isIterable = isIterable; + exports2.isString = isString; + exports2.isNumber = isNumber; + exports2.orElse = orElse; + exports2.ifNull = ifNull; + exports2.mixin = mixin2; + exports2.pipe = pipe; + function staticImplements() { + return (constructor) => { + constructor; + }; + } + function isPlainObject(value) { + return Object.getPrototypeOf(value) === Object.prototype; + } + function isFunction(value) { + return value != null && typeof value === "function"; + } + function isIterable(value) { + return isFunction(value[Symbol.iterator]); + } + function isString(value) { + return typeof value === "string"; + } + function isNumber(value) { + return !isNaN(value); + } + function orElse(thisArg, a, b2) { + return function(...args) { + const fn = a != null ? a : b2; + return fn.apply(thisArg, args); + }; + } + function ifNull(thisArg, b2, ...args) { + return function(a) { + return orElse(thisArg, a, b2).apply(thisArg, args); + }; + } + function applyMixins(derivedCtor, constructors) { + constructors.forEach((baseCtor) => { + Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => { + Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)); + }); + }); + } + function mixin2(impl) { + return function(constructor) { + applyMixins(constructor, [impl]); + return constructor; + }; + } + function pipe(arg, firstFn, ...fns) { + return fns.reduce((acc, fn) => fn(acc), firstFn(arg)); + } + } +}); + +// ../serde-ts/dist/ser/interface.js +var require_interface = __commonJS({ + "../serde-ts/dist/ser/interface.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.isGenericSerializer = isGenericSerializer; + var utils_1 = require_utils(); + var TypeSerializerMethods = [ + "serializeString", + "serializeNumber", + "serializeBigInt", + "serializeBoolean", + "serializeSymbol", + //'serializeMap', + "serializeIterable", + "serializeNull", + "serializeObject", + "serializeClass" + ]; + var AnySerializerMethods = ["serializeAny"]; + function isGenericSerializer(value) { + return AnySerializerMethods.every((k) => (0, utils_1.isFunction)(value[k])) && TypeSerializerMethods.every((k) => !(0, utils_1.isFunction)(value[k])); + } + } +}); + +// ../serde-ts/dist/case.js +var require_case = __commonJS({ + "../serde-ts/dist/case.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CaseConvention = void 0; + exports2.convertCase = convertCase; + exports2.CaseConvention = Object.freeze({ + Lowercase: 0, + Uppercase: 1, + PascalCase: 2, + CamelCase: 3, + SnakeCase: 4, + ScreamingSnakeCase: 5, + KebabCase: 6, + ScreamingKebabCase: 7 + }); + var wordBoundaryRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g; + function identifyWords(value) { + return value && value.match(wordBoundaryRegex); + } + var lower = (ch) => ch.toLowerCase(); + var upper = (ch) => ch.toUpperCase(); + var first = (xs) => xs && xs[0]; + var tail = (xs) => xs && xs.slice(1); + function upperFirst(xs) { + return upper(first(xs)) + tail(xs); + } + function toPascalCase(words) { + return words.map(lower).map(upperFirst).join(""); + } + var joinMap = (fn, delim, xs) => { + return xs.map(fn).join(delim); + }; + function convertCase(value, convention) { + const words = identifyWords(value); + if (!words || words.length <= 0) { + return ""; + } + switch (convention) { + case exports2.CaseConvention.Lowercase: + return words.join("").toLowerCase(); + case exports2.CaseConvention.Uppercase: + return words.join("").toUpperCase(); + case exports2.CaseConvention.PascalCase: + return toPascalCase(words); + case exports2.CaseConvention.CamelCase: + const pascal = toPascalCase(words); + return first(pascal).toLowerCase() + tail(pascal); + case exports2.CaseConvention.SnakeCase: + return joinMap(lower, "_", words); + case exports2.CaseConvention.ScreamingSnakeCase: + return joinMap(upper, "_", words); + case exports2.CaseConvention.KebabCase: + return joinMap(lower, "-", words); + case exports2.CaseConvention.ScreamingKebabCase: + return joinMap(upper, "-", words); + } + } + } +}); + +// ../serde-ts/dist/registry.js +var require_registry = __commonJS({ + "../serde-ts/dist/registry.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GlobalRegistry = exports2.Registry = void 0; + var Registry = class { + constructor() { + Object.defineProperty(this, "registeredClasses", { + enumerable: true, + configurable: true, + writable: true, + value: /* @__PURE__ */ new Map() + }); + } + add(ctor, key = ctor.name) { + this.registeredClasses.set(key, ctor); + } + get(name) { + return this.registeredClasses.get(name); + } + }; + exports2.Registry = Registry; + exports2.GlobalRegistry = new Registry(); + } +}); + +// ../serde-ts/dist/options.js +var require_options = __commonJS({ + "../serde-ts/dist/options.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SerdeOptions = exports2.Stage = void 0; + var case_1 = require_case(); + var utils_1 = require_utils(); + var registry_1 = require_registry(); + exports2.Stage = Object.freeze({ + Serialize: 0, + Deserialize: 1 + }); + var SerdeOptions = class { + get registry() { + return this.options.registry || registry_1.GlobalRegistry; + } + constructor(options = {}, properties = /* @__PURE__ */ new Map()) { + Object.defineProperty(this, "target", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "properties", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.options = options; + this.properties = properties; + } + static from(target) { + return new this(target); + } + getClassName(stage) { + var _a, _b; + if ((0, utils_1.isString)(this.options.rename)) { + return this.options.rename; + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isString)((_a = this.options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) { + return this.options.rename.serialize; + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isString)((_b = this.options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return this.options.rename.deserialize; + } else { + return this.target.constructor.name; + } + } + getPropertyRename(property, stage, options) { + var _a, _b; + if (options != null) { + if ((0, utils_1.isString)(options.rename)) { + return options.rename; + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isString)((_a = options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) { + return options.rename.serialize; + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isString)((_b = options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return options.rename.deserialize; + } + } + return property; + } + getPropertyCase(name, stage) { + var _a, _b; + if ((0, utils_1.isNumber)(this.options.renameAll)) { + return (0, case_1.convertCase)(name, this.options.renameAll); + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isNumber)((_a = this.options.renameAll) === null || _a === void 0 ? void 0 : _a.serialize)) { + return (0, case_1.convertCase)(name, this.options.renameAll.serialize); + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isNumber)((_b = this.options.renameAll) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return (0, case_1.convertCase)(name, this.options.renameAll.deserialize); + } else { + return name; + } + } + getPropertyName(property, stage) { + const options = this.properties.get(property); + const name = options != null ? this.getPropertyRename(property, stage, options) : property; + return this.getPropertyCase(name, stage); + } + getSerializationName(property) { + return this.getPropertyName(property, exports2.Stage.Serialize); + } + getDeserializationName(property) { + return this.getPropertyName(property, exports2.Stage.Deserialize); + } + getDefault(property) { + const options = this.properties.get(property); + if (options && (0, utils_1.isFunction)(options.default)) { + return options.default(); + } else if ((0, utils_1.isFunction)(this.options.default)) { + return this.options.default(); + } + } + //getCustomImpl(property: string, stage: Stage) { + // const options = this.properties.get(property) + // if (options != null) { + // if (stage === Stage.Serialize && isFunction(options.serializeWith)) { + // return options.serializeWith + // } else if (stage === Stage.Deserialize && isFunction(options.deserializeWith)) { + // return options.deserializeWith + // } + // } + //} + //getSerializer(property: string): Nullable { + // return this.getCustomImpl(property, Stage.Serialize) as CustomSerializer + //} + //getDeserializer(property: string): Nullable { + // return this.getCustomImpl(property, Stage.Deserialize) as CustomDeserializer + //} + isConditionalSkip(skip) { + return "if" in skip && (0, utils_1.isFunction)(skip.if); + } + shouldSkip(property, value, stage) { + const options = this.properties.get(property); + if (options != null && options.skip != null) { + if (typeof options.skip === "boolean") { + return options.skip; + } else if (this.isConditionalSkip(options.skip)) { + return options.skip.if(value); + } else if (stage === exports2.Stage.Serialize && typeof options.skip.serializing === "boolean") { + return options.skip.serializing; + } else if (stage === exports2.Stage.Serialize && this.isConditionalSkip(options.skip.serializing)) { + return options.skip.serializing.if(value); + } else if (stage === exports2.Stage.Deserialize && typeof options.skip.deserializing === "boolean") { + return options.skip.deserializing; + } else if (stage === exports2.Stage.Deserialize && this.isConditionalSkip(options.skip.deserializing)) { + return options.skip.deserializing.if(value); + } + } + return false; + } + shouldSkipSerializing(property, value) { + return this.shouldSkip(property, value, exports2.Stage.Serialize); + } + shouldSkipDeserializing(property, value) { + return this.shouldSkip(property, value, exports2.Stage.Deserialize); + } + }; + exports2.SerdeOptions = SerdeOptions; + } +}); + +// ../serde-ts/dist/ser/impl.js +var require_impl = __commonJS({ + "../serde-ts/dist/ser/impl.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.serializeWith = serializeWith3; + var options_1 = require_options(); + var utils_1 = require_utils(); + var unhandledType = (serializer, value) => new TypeError(`'${serializer.constructor.name}' has no method for value type '${typeof value}'`); + function serializeEntries(serializer, value, options) { + var _a; + let state; + for (const [key, val] of value) { + if (options === null || options === void 0 ? void 0 : options.shouldSkipSerializing(key, val)) { + continue; + } + const name = (_a = options === null || options === void 0 ? void 0 : options.getPropertyName(key, options_1.Stage.Serialize)) !== null && _a !== void 0 ? _a : key; + state = serializer.serializeKey(name); + state = serializer.serializeValue(val); + } + return serializer.end(); + } + function serializeClass(serializer, value, options) { + const ser2 = serializer.serializeClass(value.constructor.name); + return serializeEntries(ser2, Object.entries(value), options); + } + function serializeObject(serializer, value, options) { + const ser2 = serializer.serializeObject(); + return serializeEntries(ser2, Object.entries(value), options); + } + function serializeIter(serializer, value, options) { + let state; + for (const val of value) { + state = serializer.serializeElement(val); + } + return serializer.end(); + } + function defaultOptions(value) { + return value.constructor[Symbol.metadata].serde; + } + function serializeWith3(serializer, value, optionsGetter = defaultOptions) { + const serializeAny = (0, utils_1.orElse)(serializer, serializer.serializeAny, (value2) => unhandledType(serializer, value2)); + const serialize2 = (0, utils_1.ifNull)(serializer, serializeAny, value); + switch (typeof value) { + case "string": + return serialize2(serializer.serializeString); + case "number": + return serialize2(serializer.serializeNumber); + case "bigint": + return serialize2(serializer.serializeBigInt); + case "boolean": + return serialize2(serializer.serializeBoolean); + case "symbol": + return serialize2(serializer.serializeSymbol); + case "undefined": + return serialize2(serializer.serializeNull); + case "object": + const options = optionsGetter(value); + if ((0, utils_1.isIterable)(value) && (0, utils_1.isFunction)(serializer.serializeIterable)) { + return serializeIter(serializer.serializeIterable(), value, options); + } else if (!(0, utils_1.isPlainObject)(value)) { + return serializeClass(serializer, value, options); + } else if ((0, utils_1.isFunction)(serializer.serializeObject)) { + return serializeObject(serializer, value, options); + } + // deliberate fallthrough when the above fail + default: + return serializeAny(value); + } + } + } +}); + +// ../serde-ts/dist/ser/mixin.js +var require_mixin = __commonJS({ + "../serde-ts/dist/ser/mixin.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.serialize = serialize2; + var impl_1 = require_impl(); + var interface_1 = require_interface(); + function serialize2(constructor) { + class Serializable2 extends constructor { + serialize(serializer) { + if ((0, interface_1.isGenericSerializer)(serializer)) { + return serializer.serializeAny(this); + } else { + return (0, impl_1.serializeWith)(serializer, this); + } + } + } + Object.defineProperty(Serializable2, "name", { + enumerable: true, + configurable: true, + writable: true, + value: constructor.name + }); + return Serializable2; + } + } +}); + +// ../serde-ts/dist/ser/index.js +var require_ser = __commonJS({ + "../serde-ts/dist/ser/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + require_lib(); + __exportStar(require_interface(), exports2); + __exportStar(require_mixin(), exports2); + __exportStar(require_impl(), exports2); + } +}); + +// ../serde-ts/dist/de/generic.js +var require_generic = __commonJS({ + "../serde-ts/dist/de/generic.js"(exports2) { + "use strict"; + var __esDecorate = exports2 && exports2.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { + if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); + return f; + } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function(f) { + if (done) throw new TypeError("Cannot add initializers after decoration has completed"); + extraInitializers.push(accept(f || null)); + }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + }; + var __runInitializers2 = exports2 && exports2.__runInitializers || function(thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + }; + var __setFunctionName = exports2 && exports2.__setFunctionName || function(f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GenericVisitor = exports2.GenericSeed = void 0; + var utils_1 = require_utils(); + var GenericSeed = (() => { + let _classDecorators = [(0, utils_1.staticImplements)()]; + let _classDescriptor; + let _classExtraInitializers = []; + let _classThis; + var GenericSeed2 = _classThis = class { + static deserialize(deserializer) { + return deserializer.deserializeAny(new GenericVisitor2()); + } + deserialize(deserializer) { + return GenericSeed2.deserialize(deserializer); + } + }; + __setFunctionName(_classThis, "GenericSeed"); + (() => { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0; + __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers); + GenericSeed2 = _classThis = _classDescriptor.value; + if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + __runInitializers2(_classThis, _classExtraInitializers); + })(); + return GenericSeed2 = _classThis; + })(); + exports2.GenericSeed = GenericSeed; + var GenericVisitor2 = class { + visitString(value) { + return value; + } + visitNumber(value) { + return value; + } + visitBigInt(value) { + return value; + } + visitBoolean(value) { + return value; + } + visitSymbol(value) { + return value; + } + visitNull() { + return null; + } + visitObject(access) { + const result = {}; + let entry; + while (entry = access.nextEntry()) { + result[entry[0]] = entry[1]; + } + return result; + } + visitClass(name, value) { + console.log(name, "!!!!!!"); + return this.visitObject(value); + } + visitIterable(access) { + const result = new Array(access.sizeHint()); + let element; + while (element = access.nextElement()) { + result.push(element); + } + return result; + } + }; + exports2.GenericVisitor = GenericVisitor2; + } +}); + +// ../serde-ts/dist/de/interface.js +var require_interface2 = __commonJS({ + "../serde-ts/dist/de/interface.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DefaultIterableAccessImpl = exports2.DefaultMapAccessImpl = void 0; + var generic_1 = require_generic(); + var DefaultMapAccessImpl2 = class { + nextEntrySeed(kseed, vseed) { + const key = this.nextKeySeed(kseed); + if (key !== void 0) { + const value = this.nextValueSeed(vseed); + if (value !== void 0) { + return [key, value]; + } + } + } + nextKey() { + return this.nextValueSeed(generic_1.GenericSeed); + } + nextValue() { + return this.nextValueSeed(generic_1.GenericSeed); + } + nextEntry() { + return this.nextEntrySeed(generic_1.GenericSeed, generic_1.GenericSeed); + } + }; + exports2.DefaultMapAccessImpl = DefaultMapAccessImpl2; + var DefaultIterableAccessImpl2 = class { + nextElement() { + return this.nextElementSeed(generic_1.GenericSeed); + } + sizeHint() { + return 0; + } + }; + exports2.DefaultIterableAccessImpl = DefaultIterableAccessImpl2; + } +}); + +// ../serde-ts/dist/de/impl.js +var require_impl2 = __commonJS({ + "../serde-ts/dist/de/impl.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.deserializeWith = deserializeWith; + var options_1 = require_options(); + var generic_1 = require_generic(); + function deserializeWith(deserializer, into, options) { + const visitor = new generic_1.GenericVisitor(); + const target = new into(); + const obj = deserializer.deserializeClass(into.name, visitor); + const newObject = {}; + for (const property in target) { + const name = options.getPropertyName(property, options_1.Stage.Deserialize); + const value = obj[name] || options.getDefault(property); + newObject[property] = value; + delete obj[name]; + } + if (options.options.denyUnknownFields && Object.keys(obj).length > 0) { + throw new TypeError(`Unexpected fields: ${Object.keys(obj).join(", ")}`); + } + return Object.assign(target, newObject); + } + } +}); + +// ../serde-ts/dist/de/mixin.js +var require_mixin2 = __commonJS({ + "../serde-ts/dist/de/mixin.js"(exports2) { + "use strict"; + var __esDecorate = exports2 && exports2.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { + if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); + return f; + } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function(f) { + if (done) throw new TypeError("Cannot add initializers after decoration has completed"); + extraInitializers.push(accept(f || null)); + }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + }; + var __runInitializers2 = exports2 && exports2.__runInitializers || function(thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + }; + var __setFunctionName = exports2 && exports2.__setFunctionName || function(f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.deserialize = deserialize2; + var utils_1 = require_utils(); + var impl_1 = require_impl2(); + function deserialize2(constructor) { + let Deserializable = (() => { + let _classDecorators = [(0, utils_1.staticImplements)()]; + let _classDescriptor; + let _classExtraInitializers = []; + let _classThis; + let _classSuper = constructor; + var Deserializable2 = _classThis = class extends _classSuper { + static deserialize(deserializer) { + return (0, impl_1.deserializeWith)(deserializer, this, this[Symbol.metadata].serde); + } + }; + __setFunctionName(_classThis, "Deserializable"); + (() => { + var _a; + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0; + __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers); + Deserializable2 = _classThis = _classDescriptor.value; + if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + })(); + Object.defineProperty(_classThis, "name", { + enumerable: true, + configurable: true, + writable: true, + value: constructor.name + }); + (() => { + __runInitializers2(_classThis, _classExtraInitializers); + })(); + return Deserializable2 = _classThis; + })(); + return Deserializable; + } + } +}); + +// ../serde-ts/dist/de/index.js +var require_de = __commonJS({ + "../serde-ts/dist/de/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + __exportStar(require_interface2(), exports2); + __exportStar(require_generic(), exports2); + __exportStar(require_mixin2(), exports2); + } +}); + +// ../serde-ts/dist/decorator.js +var require_decorator = __commonJS({ + "../serde-ts/dist/decorator.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.serde = serde2; + exports2.register = register2; + var options_1 = require_options(); + var registry_1 = require_registry(); + function decorateContainer(target, context, options) { + const meta = context.metadata; + const serde3 = meta.serde || new options_1.SerdeOptions(target); + serde3.target = target; + serde3.options = options; + meta.serde = serde3; + } + function decorateProperty(target, context, options) { + const meta = context.metadata; + const serde3 = meta.serde || new options_1.SerdeOptions(target); + serde3.properties.set(context.name, options); + meta.serde = serde3; + } + function serde2(options) { + return function(target, context) { + if (target == null) { + decorateProperty(target, context, options); + } else + decorateContainer(target, context, options); + }; + } + function register2(registry = registry_1.GlobalRegistry) { + return function(target, _context) { + registry.add(target); + }; + } + } +}); + +// ../serde-ts/dist/index.js +var require_dist = __commonJS({ + "../serde-ts/dist/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + } + __setModuleDefault(result, mod); + return result; + }; + }(); + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.de = exports2.ser = void 0; + exports2.ser = __importStar(require_ser()); + exports2.de = __importStar(require_de()); + __exportStar(require_case(), exports2); + __exportStar(require_registry(), exports2); + __exportStar(require_decorator(), exports2); + __exportStar(require_options(), exports2); + } +}); + +// test.ts +var import_serde = __toESM(require_dist()); +var import_de3 = __toESM(require_de()); +var import_ser4 = __toESM(require_ser()); + +// src/index.ts +var import_ser2 = __toESM(require_ser()); + +// src/ser.ts +var import_ser = __toESM(require_ser()); +var JSONObjectSerializer = class { + ser; + first = true; + constructor(serializer) { + this.ser = serializer; + serializer.write("{"); + } + serializeKey(key) { + if (!this.first) { + this.ser.write(","); + } else { + this.first = false; + } + (0, import_ser.serializeWith)(this.ser, key); + this.ser.write(":"); + } + serializeValue(value) { + (0, import_ser.serializeWith)(this.ser, value); + } + end() { + this.ser.write("}"); + } +}; +var JSONIterableSerializer = class { + ser; + first = true; + constructor(serializer) { + this.ser = serializer; + serializer.write("["); + } + serializeElement(element) { + if (!this.first) { + this.ser.write(","); + } else { + this.first = false; + } + (0, import_ser.serializeWith)(this.ser, element); + } + end() { + this.ser.write("]"); + } +}; +var JSONClassSerializer = class { + outer; + inner; + constructor(serializer, name) { + this.outer = new JSONObjectSerializer(serializer); + this.outer.serializeKey("type"); + this.outer.serializeValue(name); + this.outer.serializeKey("object"); + this.inner = new JSONObjectSerializer(serializer); + } + serializeKey(key) { + return this.inner.serializeKey(key); + } + serializeValue(value) { + return this.inner.serializeValue(value); + } + end() { + this.inner.end(); + this.outer.end(); + } +}; +var JSONSerializer = class { + output = ""; + write(value) { + this.output += value; + } + serializeString(value) { + this.write(`"${value}"`); + } + serializeBoolean(value) { + this.write(value.toString()); + } + serializeSymbol(value) { + const key = Symbol.keyFor(value); + if (key) { + this.write(key); + } else { + return this.serializeString(value.toString()); + } + } + serializeObject() { + return new JSONObjectSerializer(this); + } + serializeClass(name) { + return new JSONClassSerializer(this, name); + } + serializeNumber(value) { + this.write(value.toString()); + } + serializeBigInt(value) { + this.write(value.toString()); + } + serializeIterable() { + return new JSONIterableSerializer(this); + } + serializeNull() { + return this.write("null"); + } +}; + +// src/de.ts +var import_de = __toESM(require_de()); +var import_utils = __toESM(require_utils()); + +// src/err.ts +var unexpected = (expected, actual, position) => new SyntaxError(`Expected ${expected} at position ${position} (got '${actual}')`); + +// src/de.ts +var clamp = (value, min, max) => { + return Math.min(Math.max(value, min), max); +}; +var isNumeric = (value) => { + return !isNaN(value); +}; +var isNumericToken = (value) => { + return value === Token.Period || value === Token.Hyphen || Token.Digit.includes(value); +}; +var encoder = new TextEncoder(); +var b = (strings) => encoder.encode(strings[0]); +var char = (strings) => b(strings)[0]; +var Literal = Object.freeze({ + True: b`true`, + False: b`false` +}); +var Token = Object.freeze({ + Space: char` `, + LeftCurly: char`{`, + RightCurly: char`}`, + LeftSquare: char`[`, + RightSquare: char`]`, + Quote: char`"`, + ForwardSlash: char`\\`, + Digit: b`0123456789`, + Hyphen: char`-`, + Period: char`.`, + Comma: char`,`, + Colon: char`:` +}); +var _CommaSeparated_decorators, _init; +_CommaSeparated_decorators = [(0, import_utils.mixin)(import_de.DefaultMapAccessImpl), (0, import_utils.mixin)(import_de.DefaultIterableAccessImpl)]; +var CommaSeparated = class { + de; + first = true; + constructor(deserializer) { + this.de = deserializer; + } + nextKeySeed(seed) { + if (this.de.buffer.peek().next() === Token.RightCurly) { + return; + } + if (!this.first) { + const take = this.de.buffer.take(); + if (take.next() !== Token.Comma) { + throw unexpected(",", take.toString(), this.de.buffer.position); + } + } + this.first = false; + return seed.deserialize(this.de); + } + nextValueSeed(seed) { + const next = this.de.buffer.next(); + if (next !== Token.Colon) { + throw unexpected(":", next.toString(), this.de.buffer.position); + } + return seed.deserialize(this.de); + } + nextElementSeed(seed) { + if (this.de.buffer.peek().next() === Token.RightSquare) { + return; + } + if (!this.first) { + const take = this.de.buffer.take(); + if (take.next() !== Token.Comma) { + throw unexpected(",", take.toString(), this.de.buffer.position); + } + } + this.first = false; + return seed.deserialize(this.de); + } +}; +_init = __decoratorStart(null); +CommaSeparated = __decorateElement(_init, 0, "CommaSeparated", _CommaSeparated_decorators, CommaSeparated); +__runInitializers(_init, 1, CommaSeparated); +var StringBuffer = class _StringBuffer { + view; + index = 0; + encoder; + decoder; + get position() { + return this.index; + } + get length() { + return this.view.byteLength; + } + constructor(view, encoder2 = new TextEncoder(), decoder = new TextDecoder()) { + this.view = view; + this.encoder = encoder2; + this.decoder = decoder; + } + static fromArrayBuffer(value, encoder2, decoder) { + return new this(new Uint8Array(value), encoder2, decoder); + } + static fromString(value, encoder2 = new TextEncoder(), decoder) { + return this.fromArrayBuffer( + encoder2.encode(value), + encoder2, + decoder + ); + } + next() { + const value = this.view[this.index]; + this.index += 1; + return value; + } + nextChar() { + return this.take().toString(); + } + done() { + return this.index >= this.view.byteLength; + } + toBytes() { + return this.view.slice(this.index); + } + toString() { + return this.decoder.decode(this.toBytes()); + } + take(limit = 1) { + const bytes = this.peek(limit); + this.index += limit; + return bytes; + } + at(index) { + return this.view[this.index + index]; + } + takeWhile(fn) { + let index = 0; + while (!this.done() && fn(this.at(index))) { + index += 1; + } + return this.take(index); + } + takeUntil(fn) { + return this.takeWhile((v) => !fn(v)); + } + drop(limit) { + this.index += limit; + return this; + } + dropWhile(fn) { + let index = 0; + while (!this.done() && fn(this.at(index))) { + index += 1; + } + return this.drop(index); + } + dropUntil(fn) { + return this.dropWhile((v) => !fn(v)); + } + peek(limit = 1) { + const index = this.index; + return this.slice(index, index + limit); + } + startsWith(value) { + if (typeof value === "string") { + return this.startsWith(this.encoder.encode(value)); + } + const length = value.byteLength; + const bytes = new Uint8Array(value); + return this.peek(length).toBytes().every((v, i) => v === bytes[i]); + } + slice(start, end) { + return new _StringBuffer( + this.view.subarray(start, end), + this.encoder, + this.decoder + ); + } + indexOf(value, start = 0) { + const search = new Uint8Array(isNumeric(value) ? [value] : value); + start = clamp(start, this.index, this.length); + const bytes = this.slice(start); + for (let i = 0, len = bytes.length; i < len; i++) { + if (bytes.at(i) === search[0] && bytes.slice(i).startsWith(search)) { + return i; + } + } + return -1; + } +}; +var JSONDeserializer = class { + buffer; + constructor(buffer) { + this.buffer = buffer; + } + static fromString(value) { + return new this(StringBuffer.fromString(value)); + } + deserializeAny(visitor) { + const peek = this.buffer.peek(); + const nextByte = peek.take(); + const byte = nextByte.next(); + switch (true) { + case b`n`.includes(byte): + return this.deserializeNull(visitor); + case b`tf`.includes(byte): + return this.deserializeBoolean(visitor); + case b`-0123456789`.includes(byte): + return this.deserializeNumber(visitor); + case Token.Quote === byte: + return this.deserializeString(visitor); + case Token.LeftSquare === byte: + return this.deserializeIterable(visitor); + case Token.LeftCurly === byte: + return this.deserializeObject(visitor); + default: + throw new SyntaxError(`Invalid syntax at position ${this.buffer.position}: "${nextByte.toString()}"`); + } + } + deserializeNull(visitor) { + if (this.buffer.startsWith("null")) { + this.buffer.take(4); + } + return visitor.visitNull(); + } + _deserializeObject(fn) { + let next = this.buffer.take(); + if (next.next() === Token.LeftCurly) { + const value = fn(new CommaSeparated(this)); + next = this.buffer.take(); + if (next.next() === Token.RightCurly) { + return value; + } else { + throw unexpected("}", next.toString(), this.buffer.position); + } + } else { + throw unexpected("{", next.toString(), this.buffer.position); + } + } + deserializeObject(visitor) { + return this._deserializeObject(visitor.visitObject.bind(visitor)); + } + deserializeClass(name, visitor) { + if (this.buffer.peek(9).startsWith('{"type":"')) { + const name2 = this.buffer.drop(9).takeUntil((v) => v === Token.Quote); + if (this.buffer.startsWith('","object":')) { + this.buffer.drop(11); + return this._deserializeObject(visitor.visitClass.bind(visitor, name2.toString())); + } else { + throw unexpected('"object" property', this.buffer.toString(), this.buffer.position); + } + } else { + throw unexpected('"type" property', this.buffer.toString(), this.buffer.position); + } + } + deserializeString(visitor) { + const next = this.buffer.take(); + if (next.next() === Token.Quote) { + let index = -1; + do { + index = this.buffer.indexOf(Token.Quote, index); + } while (index > -1 && this.buffer.at(index - 1) === Token.ForwardSlash); + if (index === -1) { + throw new SyntaxError("Unterminated string literal"); + } + const bytes = this.buffer.take(index); + this.buffer.take(); + return visitor.visitString(bytes.toString()); + } else { + throw unexpected('"', next.toString(), this.buffer.position); + } + } + deserializeNumber(visitor) { + const next = this.buffer.peek().next(); + if (isNumericToken(next)) { + const digits = this.buffer.takeWhile(isNumericToken).toString(); + if (digits.length >= 16) { + const number = BigInt(digits); + return visitor.visitBigInt(number); + } else if (digits.length > 0) { + let number = parseInt(digits.toString(), 10); + return visitor.visitNumber(number); + } + } + throw unexpected('"-", ".", or 0..=9', next.toString(), this.buffer.position); + } + deserializeBigInt(visitor) { + return this.deserializeNumber(visitor); + } + deserializeBoolean(visitor) { + const next = this.buffer.next(); + let length = 3; + switch (next) { + case Literal.False[0]: + length = 4; + case Literal.True[0]: + break; + default: + throw unexpected('"true" or "false"', this.buffer.next().toString(), this.buffer.position); + } + this.buffer.take(length); + return visitor.visitBoolean(length === 3); + } + deserializeSymbol(_visitor) { + throw new Error("Method not implemented."); + } + deserializeIterable(visitor) { + let next = this.buffer.take(); + if (next.next() === Token.LeftSquare) { + const value = visitor.visitIterable(new CommaSeparated(this)); + next = this.buffer.take(); + if (next.next() === Token.RightSquare) { + return value; + } else { + throw unexpected("]", next.toString(), this.buffer.position); + } + } else { + throw unexpected("[", next.toString(), this.buffer.position); + } + } +}; + +// src/index.ts +function toString(value) { + const serializer = new JSONSerializer(); + (0, import_ser2.serializeWith)(serializer, value); + return serializer.output; +} +function fromString(value, into) { + const deserializer = JSONDeserializer.fromString(value); + return into.deserialize(deserializer); +} + +// test.ts +var _metadata_dec, _InnerStruct_decorators, _init2; +_InnerStruct_decorators = [import_ser4.serialize, import_de3.deserialize, (0, import_serde.register)(), (0, import_serde.serde)({ renameAll: import_serde.CaseConvention.PascalCase })], _metadata_dec = [(0, import_serde.serde)({ skip: true })]; +var InnerStruct = class { + constructor(v) { + __publicField(this, "value"); + __publicField(this, "metadata", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this); + this.value = v; + } +}; +_init2 = __decoratorStart(null); +__decorateElement(_init2, 5, "metadata", _metadata_dec, InnerStruct); +InnerStruct = __decorateElement(_init2, 0, "InnerStruct", _InnerStruct_decorators, InnerStruct); +__runInitializers(_init2, 1, InnerStruct); +var _aBoolean_dec, _TestStruct_decorators, _init3; +_TestStruct_decorators = [import_ser4.serialize, import_de3.deserialize, (0, import_serde.register)(), (0, import_serde.serde)({ renameAll: import_serde.CaseConvention.SnakeCase })], _aBoolean_dec = [(0, import_serde.serde)({ skip: { serializing: { if: (v) => v } } })]; +var TestStruct = class { + constructor(str) { + __publicField(this, "aNumber", 69); + __publicField(this, "aString"); + __publicField(this, "aBoolean", __runInitializers(_init3, 8, this, false)), __runInitializers(_init3, 11, this); + __publicField(this, "innerStruct"); + this.innerStruct = new InnerStruct(str); + } +}; +_init3 = __decoratorStart(null); +__decorateElement(_init3, 5, "aBoolean", _aBoolean_dec, TestStruct); +TestStruct = __decorateElement(_init3, 0, "TestStruct", _TestStruct_decorators, TestStruct); +__runInitializers(_init3, 1, TestStruct); +var test = new TestStruct("hi :3"); +console.log(test.constructor.name); +var ser = toString(test); +console.log(ser); +var de = fromString(ser, TestStruct); +console.log(de); diff --git a/src/de.ts b/src/de.ts index ba64325..1ed536d 100644 --- a/src/de.ts +++ b/src/de.ts @@ -74,7 +74,6 @@ export class CommaSeparated implements MapAccess, IterableAccess { nextValueSeed>(seed: V): Nullable { const next = this.de.buffer.next() if (next !== Token.Colon) { - console.log(this.de.buffer.toString()) throw unexpected(':', next.toString(), this.de.buffer.position) } @@ -172,11 +171,29 @@ class StringBuffer { return this.take(index) } + takeUntil(fn: Predicate): StringBuffer { + return this.takeWhile((v: number) => !fn(v)) + } + drop(limit: number) { this.index += limit return this } + dropWhile(fn: Predicate): StringBuffer { + let index = 0 + + while (!this.done() && fn(this.at(index))) { + index += 1 + } + + return this.drop(index) + } + + dropUntil(fn: Predicate): StringBuffer { + return this.dropWhile((v: number) => !fn(v)) + } + peek(limit: number = 1): StringBuffer { const index = this.index return this.slice(index, index + limit) @@ -279,6 +296,22 @@ export class JSONDeserializer implements Deserializer { return this._deserializeObject(visitor.visitObject.bind(visitor)) } + deserializeClass>(name: string, visitor: V): T { + if (this.buffer.peek(9).startsWith('{"type":"')) { + const name = this.buffer.drop(9).takeUntil((v: number) => v === Token.Quote) + + if (this.buffer.startsWith('","object":')) { + this.buffer.drop(11) + return this._deserializeObject(visitor.visitClass.bind(visitor, name.toString())) + } else { + throw unexpected('"object" property', this.buffer.toString(), this.buffer.position) + } + + } else { + throw unexpected('"type" property', this.buffer.toString(), this.buffer.position) + } + } + deserializeString>(visitor: V): T { const next = this.buffer.take() if (next.next() === Token.Quote) { diff --git a/src/index.ts b/src/index.ts index b2240b9..b0feaef 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,6 +1,6 @@ import { serializeWith } from 'serde/ser' -import { Deserialize } from 'serde/de' import { JSONSerializer } from './ser' +import { Deserialize } from 'serde/de' import { JSONDeserializer } from './de' export function toString(value: any): string { diff --git a/src/ser.ts b/src/ser.ts index 922afc0..a9fd4ab 100644 --- a/src/ser.ts +++ b/src/ser.ts @@ -1,7 +1,5 @@ import { IterableSerializer, ObjectSerializer, Serializable, Serializer, serializeWith } from 'serde/ser' -const Identifier = (value: string) => `\x02${value}\x04` - class JSONObjectSerializer implements ObjectSerializer { private ser: JSONSerializer private first: boolean = true @@ -55,6 +53,34 @@ class JSONIterableSerializer implements IterableSerializer { } } +class JSONClassSerializer implements ObjectSerializer { + outer: JSONObjectSerializer + inner: JSONObjectSerializer + + constructor(serializer: JSONSerializer, name: string) { + this.outer = new JSONObjectSerializer(serializer) + + this.outer.serializeKey('type') + this.outer.serializeValue(name) + + this.outer.serializeKey('object') + this.inner = new JSONObjectSerializer(serializer) + } + + serializeKey(key: U): void { + return this.inner.serializeKey(key) + } + + serializeValue(value: U): void { + return this.inner.serializeValue(value) + } + + end(): void { + this.inner.end() + this.outer.end() + } +} + export class JSONSerializer implements Serializer { output: string = '' @@ -83,6 +109,10 @@ export class JSONSerializer implements Serializer { return new JSONObjectSerializer(this) } + serializeClass(name: PropertyKey): ObjectSerializer { + return new JSONClassSerializer(this, name as string) + } + serializeNumber(value: number) { this.write(value.toString()) }