From 36ee6dcc73bf0be3f810fb62ab09a9e87b117e47 Mon Sep 17 00:00:00 2001 From: rowan Date: Sat, 24 May 2025 04:09:56 -0500 Subject: [PATCH] remove ts errors --- dist/test.js | 843 ++++++++++++++++++++++++++++++++++++++++----------- src/de.ts | 20 +- src/index.ts | 2 +- 3 files changed, 679 insertions(+), 186 deletions(-) diff --git a/dist/test.js b/dist/test.js index 7578372..cbea957 100644 --- a/dist/test.js +++ b/dist/test.js @@ -5,6 +5,12 @@ 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; }; @@ -24,6 +30,54 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge 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({ @@ -31,17 +85,11 @@ var require_utils = __commonJS({ "use strict"; Object.defineProperty(exports2, "__esModule", { value: true }); exports2.IterResult = void 0; - exports2.staticImplements = staticImplements; exports2.isPlainObject = isPlainObject; exports2.isFunction = isFunction; exports2.isIterable = isIterable; exports2.isString = isString; exports2.isNumber = isNumber; - function staticImplements() { - return (constructor) => { - constructor; - }; - } function isPlainObject(value) { return Object.getPrototypeOf(value) === Object.prototype; } @@ -81,18 +129,26 @@ var require_impl = __commonJS({ super(`unhandled type: '${typeof value}' for serializer ${serializer.constructor.name}`); } }; - function serializeObject(serializer, obj) { + function serializeObject(serializer, obj, options) { for (const key in obj) { - serializer.serializeEntry(key, obj[key]); + const value = obj[key]; + if (options === null || options === void 0 ? void 0 : options.shouldSerialize(key, value)) { + const name = (options === null || options === void 0 ? void 0 : options.getSerializationPropertyName(key)) || key; + serializer.serializeEntry(name, value); + } } return serializer.end(); } - function serializeClass(serializer, value) { + function serializeClass(serializer, value, options) { const name = value.constructor.name; const ser = serializer.serializeClass(name); - return serializeObject(ser, value); + return serializeObject(ser, value, options); } - function serialize3(serializer, value) { + var defaultGetter = (value) => { + var _a; + return (_a = value.constructor[Symbol.metadata]) === null || _a === void 0 ? void 0 : _a.serde; + }; + function serialize3(serializer, value, optionsGetter = defaultGetter) { switch (typeof value) { case "string": return serializer.serializeString(value); @@ -107,13 +163,14 @@ var require_impl = __commonJS({ case "undefined": return serializer.serializeNull(); case "object": + const options = optionsGetter(value); switch (true) { case value == null: return serializer.serializeNull(); case !(0, utils_1.isPlainObject)(value): - return serializeClass(serializer, value); + return serializeClass(serializer, value, options); default: - return serializeObject(serializer.serializeObject(), value); + return serializeObject(serializer.serializeObject(), value, options); } default: throw new UnhandledTypeError(serializer, value); @@ -157,6 +214,233 @@ var require_registry = __commonJS({ } }); +// ../serde-ts/dist/de/generic.js +var require_generic = __commonJS({ + "../serde-ts/dist/de/generic.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ProxyDeserializer = exports2.ProxyVisitor = exports2.GenericSeed = void 0; + var utils_1 = require_utils(); + var GenericSeed2 = class _GenericSeed { + constructor(visitor = new ProxyVisitor2()) { + Object.defineProperty(this, "visitor", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.visitor = visitor; + } + static deserialize(deserializer, visitor = new ProxyVisitor2()) { + return deserializer.deserializeAny(visitor); + } + deserialize(deserializer) { + return _GenericSeed.deserialize(deserializer, this.visitor); + } + }; + exports2.GenericSeed = GenericSeed2; + var ProxyMapAccess = class _ProxyMapAccess { + constructor(access, options) { + Object.defineProperty(this, "access", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + if (access instanceof _ProxyMapAccess) { + return this; + } + this.access = access; + this.options = options; + } + wrapResponse(result) { + var _a, _b, _c, _d; + if (result.done) { + return result; + } else if ((0, utils_1.isString)(result.value)) { + const key = (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.getDeserializationPropertyName(result.value)) !== null && _b !== void 0 ? _b : result.value; + return utils_1.IterResult.Next(key); + } else if (Array.isArray(result.value)) { + const [alias, value] = result.value; + const key = (_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.getDeserializationPropertyName(alias)) !== null && _d !== void 0 ? _d : alias; + return utils_1.IterResult.Next([ + key, + value + ]); + } else { + return result; + } + } + nextKeySeed(seed) { + return this.wrapResponse(this.access.nextKeySeed(seed)); + } + nextValueSeed(seed) { + return this.access.nextValueSeed(seed); + } + nextEntrySeed(kseed, vseed) { + return this.wrapResponse(this.access.nextEntrySeed(kseed, vseed)); + } + nextKey() { + return this.wrapResponse(this.access.nextKey()); + } + nextValue() { + return this.access.nextValue(); + } + nextEntry() { + return this.wrapResponse(this.access.nextEntry()); + } + sizeHint() { + var _a, _b; + return (_b = (_a = this.access).sizeHint) === null || _b === void 0 ? void 0 : _b.call(_a); + } + *generate(next) { + let item; + while ((item = next()) && !item.done) { + yield item.value; + } + } + keys(seed) { + return this.generate(seed == null ? this.nextKey.bind(this) : this.nextKeySeed.bind(this, seed)); + } + values(seed) { + return this.generate(seed == null ? this.nextValue.bind(this) : this.nextValueSeed.bind(this, seed)); + } + entries(kseed, vseed) { + return this.generate(kseed == null || vseed == null ? this.nextEntry.bind(this) : this.nextEntrySeed.bind(this, kseed, vseed)); + } + [Symbol.iterator]() { + return this.entries(); + } + }; + var ProxyVisitor2 = class _ProxyVisitor { + constructor(overrides, options) { + Object.defineProperty(this, "overrides", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + if (overrides instanceof _ProxyVisitor) { + return overrides; + } + this.overrides = overrides; + this.options = options; + } + visitBoolean(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBoolean) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitNumber(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNumber) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitBigInt(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBigInt) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitString(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitString) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitSymbol(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitNull() { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNull) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null; + } + visitObject(access) { + var _a, _b; + const proxy = new ProxyMapAccess(access, this.options); + if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitObject)) { + return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitObject(proxy); + } + const result = []; + let entry; + while ((entry = proxy.nextEntry()) && !entry.done) { + result.push(entry.value); + } + return Object.fromEntries(result); + } + visitIterable(access) { + var _a, _b; + if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitIterable)) { + return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitIterable(access); + } + const result = []; + let element; + while (element = access.nextElement()) { + result.push(element); + } + return result; + } + }; + exports2.ProxyVisitor = ProxyVisitor2; + var ProxyDeserializer = class { + constructor(deserializer, options) { + Object.defineProperty(this, "deserializer", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.deserializer = deserializer; + this.options = options; + } + deserializeAny(visitor) { + return this.deserializer.deserializeAny(new ProxyVisitor2(visitor, this.options)); + } + deserializeBoolean(visitor) { + return this.deserializer.deserializeBoolean(new ProxyVisitor2(visitor, this.options)); + } + deserializeNumber(visitor) { + return this.deserializer.deserializeNumber(new ProxyVisitor2(visitor, this.options)); + } + deserializeBigInt(visitor) { + return this.deserializer.deserializeBigInt(new ProxyVisitor2(visitor, this.options)); + } + deserializeString(visitor) { + return this.deserializer.deserializeString(new ProxyVisitor2(visitor, this.options)); + } + deserializeSymbol(visitor) { + return this.deserializer.deserializeSymbol(new ProxyVisitor2(visitor, this.options)); + } + deserializeNull(visitor) { + return this.deserializer.deserializeNull(new ProxyVisitor2(visitor, this.options)); + } + deserializeObject(visitor) { + return this.deserializer.deserializeObject(new ProxyVisitor2(visitor, this.options)); + } + deserializeIterable(visitor) { + return this.deserializer.deserializeIterable(new ProxyVisitor2(visitor, this.options)); + } + deserializeFunction(visitor) { + return this.deserializer.deserializeFunction(new ProxyVisitor2(visitor, this.options)); + } + }; + exports2.ProxyDeserializer = ProxyDeserializer; + } +}); + // ../serde-ts/dist/de/impl.js var require_impl2 = __commonJS({ "../serde-ts/dist/de/impl.js"(exports2) { @@ -164,12 +448,14 @@ var require_impl2 = __commonJS({ Object.defineProperty(exports2, "__esModule", { value: true }); exports2.deserialize = deserialize3; var registry_1 = require_registry(); + var generic_1 = require_generic(); function deserialize3(deserializer, into, registry = registry_1.GlobalRegistry) { + var _a; const de2 = registry.deserializers.get(into); if (de2 == null) { throw new ReferenceError(`No deserializer for ${into.name}`); } else { - return de2(deserializer); + return de2(new generic_1.ProxyDeserializer(deserializer, (_a = into === null || into === void 0 ? void 0 : into[Symbol.metadata]) === null || _a === void 0 ? void 0 : _a.serde)); } } } @@ -237,6 +523,246 @@ var require_case = __commonJS({ } }); +// ../serde-ts/dist/option.js +var require_option = __commonJS({ + "../serde-ts/dist/option.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SerdeOptions = exports2.PropertyMap = exports2.Stage = void 0; + var case_1 = require_case(); + var utils_1 = require_utils(); + exports2.Stage = Object.freeze({ + Serialize: 0, + Deserialize: 1 + }); + var PropertyMap = class extends Map { + constructor(options, iterable) { + super(iterable); + Object.defineProperty(this, "options", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "aliases", { + enumerable: true, + configurable: true, + writable: true, + value: /* @__PURE__ */ new Map() + }); + this.options = options; + this.buildAliasMap(); + } + setAliasesFromOptions(key, options) { + this.aliases.set(key, key); + if (options.alias != null) { + this.addAlias(options.alias, key); + } + if ((0, utils_1.isString)(options.rename)) { + this.aliases.set(options.rename, key); + } else if ((0, utils_1.isNumber)(this.options.container.renameAll)) { + this.aliases.set(this.options.applyCaseConvention(exports2.Stage.Deserialize, key), key); + } + } + set(key, value) { + super.set(key, value); + this.setAliasesFromOptions(key, value); + return this; + } + addAlias(alias, key) { + if ((0, utils_1.isString)(alias)) { + this.aliases.set(alias, key); + } else if ((0, utils_1.isIterable)(alias)) { + for (const a of alias) { + this.addAlias(a, key); + } + } + } + getFieldFromAlias(alias) { + return this.aliases.get(alias); + } + buildAliasMap() { + for (const [key, value] of this.entries()) { + if (value.alias != null) { + this.addAlias(value.alias, key); + } + } + } + }; + exports2.PropertyMap = PropertyMap; + var SerdeOptions = class { + constructor(target, container = {}, properties = new PropertyMap(this)) { + Object.defineProperty(this, "target", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "container", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "properties", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.target = target; + this.container = container; + this.properties = properties; + } + getClassName(stage, defaultName) { + var _a, _b, _c, _d; + if (defaultName === void 0) { + defaultName = (_b = (_a = this.target) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name; + } + if ((0, utils_1.isString)(this.container.rename)) { + return this.container.rename; + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isString)((_c = this.container.rename) === null || _c === void 0 ? void 0 : _c.serialize)) { + return this.container.rename.serialize; + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isString)((_d = this.container.rename) === null || _d === void 0 ? void 0 : _d.deserialize)) { + return this.container.rename.serialize; + } else { + return defaultName; + } + } + getSerializedClassName(defaultName) { + var _a, _b; + if (defaultName === void 0) { + defaultName = (_b = (_a = this.target) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name; + } + return this.getClassName(exports2.Stage.Serialize, defaultName); + } + getDeserializedClassName(defaultName) { + var _a, _b; + if (defaultName === void 0) { + defaultName = (_b = (_a = this.target) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name; + } + return this.getClassName(exports2.Stage.Deserialize, defaultName); + } + getCaseConvention(stage) { + var _a, _b; + if ((0, utils_1.isNumber)(this.container.renameAll)) { + if (stage === exports2.Stage.Serialize) { + return this.container.renameAll; + } else { + return case_1.CaseConvention.CamelCase; + } + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isNumber)((_a = this.container.renameAll) === null || _a === void 0 ? void 0 : _a.serialize)) { + return this.container.renameAll.serialize; + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isNumber)((_b = this.container.renameAll) === null || _b === void 0 ? void 0 : _b.deserialize)) { + return this.container.renameAll.deserialize; + } + } + applyCaseConvention(stage, property) { + const convention = this.getCaseConvention(stage); + return convention != null ? (0, case_1.convertCase)(property, convention) : property; + } + getPropertyRename(stage, property) { + var _a, _b; + const options = this.properties.get(property); + if (options == null) { + return; + } else 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; + } + } + getSerializationPropertyName(property) { + return this.getPropertyRename(exports2.Stage.Serialize, property) || this.applyCaseConvention(exports2.Stage.Serialize, property); + } + getNameFromAlias(alias) { + return this.properties.getFieldFromAlias(alias); + } + getDeserializationPropertyName(property) { + return this.getNameFromAlias(property) || this.applyCaseConvention(exports2.Stage.Deserialize, property); + } + shouldSkip(stage, property, value) { + var _a, _b, _c, _d; + const options = this.properties.get(property); + if (options == null) { + return false; + } else if (typeof options.skip === "boolean") { + return options.skip; + } else if ((0, utils_1.isFunction)(options.skip)) { + return options.skip(value); + } else if (stage === exports2.Stage.Serialize && typeof ((_a = options.skip) === null || _a === void 0 ? void 0 : _a.serialize) === "boolean") { + return options.skip.serialize; + } else if (stage === exports2.Stage.Serialize && (0, utils_1.isFunction)((_b = options.skip) === null || _b === void 0 ? void 0 : _b.serialize)) { + return options.skip.serialize(value); + } else if (stage === exports2.Stage.Deserialize && typeof ((_c = options.skip) === null || _c === void 0 ? void 0 : _c.deserialize) === "boolean") { + return options.skip.deserialize; + } else if (stage === exports2.Stage.Deserialize && (0, utils_1.isFunction)((_d = options.skip) === null || _d === void 0 ? void 0 : _d.deserialize)) { + return options.skip.deserialize(value); + } else { + return false; + } + } + shouldSerialize(property, value) { + return !this.shouldSkip(exports2.Stage.Serialize, property, value); + } + shouldDeserialize(property, value) { + return !this.shouldSkip(exports2.Stage.Deserialize, property, value); + } + defaultFor(property) { + const options = this.properties.get(property); + if (options != null && (0, utils_1.isFunction)(options.default)) { + return options.default(); + } else if ((0, utils_1.isFunction)(this.container.default)) { + return this.container.default(); + } + } + }; + exports2.SerdeOptions = SerdeOptions; + } +}); + +// ../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; + var option_1 = require_option(); + var ContextKind = Object.freeze({ + Class: "class", + Method: "method", + Getter: "getter", + Setter: "setter", + Field: "field", + Accessor: "accessor" + }); + function decorateClass(target, context, options) { + const serde3 = context.metadata.serde; + context.metadata.serde = new option_1.SerdeOptions(target, options, serde3 === null || serde3 === void 0 ? void 0 : serde3.properties); + } + function decorateField(context, options) { + const serde3 = context.metadata.serde || new option_1.SerdeOptions(void 0); + serde3.properties.set(context.name, options); + context.metadata.serde = serde3; + } + function serde2(options) { + return function(target, context) { + switch (context.kind) { + case ContextKind.Class: + decorateClass(target, context, options); + break; + case ContextKind.Field: + decorateField(context, options); + default: + break; + } + }; + } + } +}); + // ../serde-ts/dist/index.js var require_dist = __commonJS({ "../serde-ts/dist/index.js"(exports2) { @@ -283,91 +809,19 @@ var require_dist = __commonJS({ }; Object.defineProperty(exports2, "__esModule", { value: true }); exports2.de = exports2.ser = void 0; + require_lib(); exports2.ser = __importStar(require_impl()); exports2.de = __importStar(require_impl2()); + __exportStar(require_decorator(), exports2); + __exportStar(require_option(), exports2); __exportStar(require_case(), exports2); __exportStar(require_registry(), exports2); __exportStar(require_utils(), exports2); } }); -// ../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.Serializer = exports2.SerializeIterable = exports2.SerializeObject = void 0; - var SerializeObject2 = class { - serializeEntry(key, value) { - this.serializeKey(key); - this.serializeValue(value); - } - }; - exports2.SerializeObject = SerializeObject2; - var SerializeIterable = class { - }; - exports2.SerializeIterable = SerializeIterable; - var Serializer = class { - serializeAny(_value) { - throw new Error("Method not implemented."); - } - serializeBoolean(_value) { - throw new Error("Method not implemented."); - } - serializeNumber(_value) { - throw new Error("Method not implemented."); - } - serializeBigInt(_value) { - throw new Error("Method not implemented."); - } - serializeString(_value) { - throw new Error("Method not implemented."); - } - serializeSymbol(_value) { - throw new Error("Method not implemented."); - } - serializeNull() { - throw new Error("Method not implemented."); - } - serializeObject() { - throw new Error("Method not implemented."); - } - serializeClass(_name) { - throw new Error("Method not implemented."); - } - }; - exports2.Serializer = Serializer; - } -}); - -// ../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 }); - __exportStar(require_impl(), exports2); - __exportStar(require_interface(), exports2); - } -}); - // ../serde-ts/dist/de/interface.js -var require_interface2 = __commonJS({ +var require_interface = __commonJS({ "../serde-ts/dist/de/interface.js"(exports2) { "use strict"; Object.defineProperty(exports2, "__esModule", { value: true }); @@ -394,6 +848,24 @@ var require_interface2 = __commonJS({ } return utils_1.IterResult.Done(); } + *generate(next) { + let item; + while (item = next()) { + yield item.value; + } + } + keys(seed) { + return this.generate(seed == null ? this.nextKey.bind(this) : this.nextKeySeed.bind(this, seed)); + } + values(seed) { + return this.generate(seed == null ? this.nextValue.bind(this) : this.nextValueSeed.bind(this, seed)); + } + entries(kseed, vseed) { + return this.generate(kseed == null || vseed == null ? this.nextEntry.bind(this) : this.nextEntrySeed.bind(this, kseed, vseed)); + } + [Symbol.iterator]() { + return this.entries(); + } }; exports2.MapAccess = MapAccess2; var IterableAccess = class { @@ -409,17 +881,17 @@ var require_forward = __commonJS({ Object.defineProperty(exports2, "__esModule", { value: true }); exports2.Forward = exports2.ForwardIterableAccess = exports2.ForwardMapAccess = void 0; var utils_1 = require_utils(); - var interface_1 = require_interface2(); + var interface_1 = require_interface(); var ForwardMapAccess = class _ForwardMapAccess extends interface_1.MapAccess { constructor(keys, values) { super(); - Object.defineProperty(this, "keys", { + Object.defineProperty(this, "_keys", { enumerable: true, configurable: true, writable: true, value: void 0 }); - Object.defineProperty(this, "values", { + Object.defineProperty(this, "_values", { enumerable: true, configurable: true, writable: true, @@ -437,8 +909,8 @@ var require_forward = __commonJS({ writable: true, value: 0 }); - this.keys = keys; - this.values = values; + this._keys = keys; + this._values = values; } static fromObject(obj) { return new _ForwardMapAccess(Object.keys(obj), Object.values(obj)); @@ -451,14 +923,14 @@ var require_forward = __commonJS({ } nextKey() { if (this.kindex < this.keys.length) { - return utils_1.IterResult.Next(this.keys[this.kindex++]); + return utils_1.IterResult.Next(this._keys[this.kindex++]); } else { return utils_1.IterResult.Done(); } } nextValue() { if (this.vindex < this.values.length) { - return utils_1.IterResult.Next(this.values[this.vindex++]); + return utils_1.IterResult.Next(this._values[this.vindex++]); } else { return utils_1.IterResult.Done(); } @@ -539,70 +1011,6 @@ var require_forward = __commonJS({ } }); -// ../serde-ts/dist/de/generic.js -var require_generic = __commonJS({ - "../serde-ts/dist/de/generic.js"(exports2) { - "use strict"; - Object.defineProperty(exports2, "__esModule", { value: true }); - exports2.GenericVisitor = exports2.GenericSeed = void 0; - var GenericSeed2 = class _GenericSeed { - constructor(visitor = new GenericVisitor3()) { - Object.defineProperty(this, "visitor", { - enumerable: true, - configurable: true, - writable: true, - value: void 0 - }); - this.visitor = visitor; - } - static deserialize(deserializer, visitor = new GenericVisitor3()) { - return deserializer.deserializeAny(visitor); - } - deserialize(deserializer) { - return _GenericSeed.deserialize(deserializer, this.visitor); - } - }; - exports2.GenericSeed = GenericSeed2; - var GenericVisitor3 = class { - visitBoolean(value) { - return value; - } - visitNumber(value) { - return value; - } - visitBigInt(value) { - return value; - } - visitString(value) { - return value; - } - visitSymbol(value) { - return value; - } - visitNull() { - return null; - } - visitObject(access) { - const result = []; - let entry; - while ((entry = access.nextEntry()) && !entry.done) { - result.push(entry.value); - } - return Object.fromEntries(result); - } - visitIterable(access) { - const result = []; - let element; - while (element = access.nextElement()) { - result.push(element); - } - return result; - } - }; - exports2.GenericVisitor = GenericVisitor3; - } -}); - // ../serde-ts/dist/de/index.js var require_de = __commonJS({ "../serde-ts/dist/de/index.js"(exports2) { @@ -627,12 +1035,88 @@ var require_de = __commonJS({ __exportStar(require_forward(), exports2); __exportStar(require_generic(), exports2); __exportStar(require_impl2(), exports2); + __exportStar(require_interface(), exports2); + } +}); + +// ../serde-ts/dist/ser/interface.js +var require_interface2 = __commonJS({ + "../serde-ts/dist/ser/interface.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Serializer = exports2.SerializeIterable = exports2.SerializeObject = void 0; + var SerializeObject2 = class { + serializeEntry(key, value) { + this.serializeKey(key); + this.serializeValue(value); + } + }; + exports2.SerializeObject = SerializeObject2; + var SerializeIterable = class { + }; + exports2.SerializeIterable = SerializeIterable; + var Serializer = class { + serializeAny(_value) { + throw new Error("Method not implemented."); + } + serializeBoolean(_value) { + throw new Error("Method not implemented."); + } + serializeNumber(_value) { + throw new Error("Method not implemented."); + } + serializeBigInt(_value) { + throw new Error("Method not implemented."); + } + serializeString(_value) { + throw new Error("Method not implemented."); + } + serializeSymbol(_value) { + throw new Error("Method not implemented."); + } + serializeNull() { + throw new Error("Method not implemented."); + } + serializeObject() { + throw new Error("Method not implemented."); + } + serializeClass(_name) { + throw new Error("Method not implemented."); + } + }; + exports2.Serializer = Serializer; + } +}); + +// ../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 }); + __exportStar(require_impl(), exports2); __exportStar(require_interface2(), exports2); } }); // test.ts var import_serde2 = __toESM(require_dist()); +var import_de4 = __toESM(require_de()); // src/ser.ts var import_ser = __toESM(require_ser()); @@ -722,13 +1206,13 @@ var JSONSerializer = class { var import_de2 = __toESM(require_de()); // src/de.ts +var import_serde = __toESM(require_dist()); var import_de = __toESM(require_de()); // src/err.ts var unexpected = (expected, actual, position) => new SyntaxError(`Expected ${expected} at position ${position} (got '${actual}')`); // src/de.ts -var import_serde = __toESM(require_dist()); var clamp = (value, min, max) => { return Math.min(Math.max(value, min), max); }; @@ -763,7 +1247,7 @@ var CommaSeparated = class extends import_de.MapAccess { de; defaultSeed; first = true; - constructor(deserializer, visitor = new import_de.GenericVisitor()) { + constructor(deserializer, visitor = new import_de.ProxyVisitor()) { super(); this.de = deserializer; this.defaultSeed = new import_de.GenericSeed(visitor); @@ -1050,24 +1534,34 @@ function fromString(value, into) { } // test.ts -var import_de4 = __toESM(require_de()); +var _value_dec, _init; +_value_dec = [(0, import_serde2.serde)({ rename: "a_string" })]; var InnerStruct = class { - value; constructor(v) { + __publicField(this, "value", __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this); this.value = v; } }; +_init = __decoratorStart(null); +__decorateElement(_init, 5, "value", _value_dec, InnerStruct); +__decoratorMetadata(_init, InnerStruct); +var _aNumber_dec, _TestStruct_decorators, _init2; +_TestStruct_decorators = [(0, import_serde2.serde)({ renameAll: { serialize: import_serde2.CaseConvention.SnakeCase, deserialize: import_serde2.CaseConvention.CamelCase } })], _aNumber_dec = [(0, import_serde2.serde)({ rename: "a_number", skip: (v) => v == 79 })]; var TestStruct = class { - aNumber; - innerStruct; constructor(str2, n) { + __publicField(this, "aNumber", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this); + __publicField(this, "innerStruct"); this.aNumber = n; this.innerStruct = new InnerStruct(str2); } }; +_init2 = __decoratorStart(null); +__decorateElement(_init2, 5, "aNumber", _aNumber_dec, TestStruct); +TestStruct = __decorateElement(_init2, 0, "TestStruct", _TestStruct_decorators, TestStruct); +__runInitializers(_init2, 1, TestStruct); var test = new TestStruct("hi :3", 69); -(0, import_serde2.registerSerializer)(InnerStruct, (ser, value) => ser.serializeAny(value)); -(0, import_serde2.registerDeserializer)(InnerStruct, (de2) => de2.deserializeObject(Object.assign(new import_de4.GenericVisitor(), { +(0, import_serde2.registerSerializer)(InnerStruct, (ser, value) => ser.serializeAny?.(value)); +(0, import_serde2.registerDeserializer)(InnerStruct, (de2) => de2.deserializeObject({ visitObject(access) { let value; let entry; @@ -1080,13 +1574,12 @@ var test = new TestStruct("hi :3", 69); } return new InnerStruct(value); } -}))); -(0, import_serde2.registerDeserializer)(TestStruct, (de2) => de2.deserializeObject(Object.assign(new import_de4.GenericVisitor(), { +})); +(0, import_serde2.registerDeserializer)(TestStruct, (de2) => de2.deserializeObject({ visitObject(access) { let str2, num; - let entry; - while ((entry = access.nextEntry()) && !entry.done) { - const [key, value] = entry.value; + for (const entry of access) { + const [key, value] = entry; switch (key) { case "aNumber": num = value; @@ -1099,7 +1592,7 @@ var test = new TestStruct("hi :3", 69); } return new TestStruct(str2, num); } -}))); +})); (0, import_serde2.registerSerializer)(TestStruct, (ser, value) => ser.serializeAny(value)); var str = toString(test); console.log(str); diff --git a/src/de.ts b/src/de.ts index a6f16be..c66e695 100644 --- a/src/de.ts +++ b/src/de.ts @@ -1,5 +1,5 @@ import { GlobalRegistry, IterResult, Registry } from 'serde' -import { IIterableAccess, MapAccess, IVisitor, IDeserializer, Deserialize, GenericVisitor, GenericSeed } from 'serde/de' +import { IIterableAccess, MapAccess, IVisitor, IDeserializer, Deserialize, ProxyVisitor, GenericSeed } from 'serde/de' import { unexpected } from './err' type Byte = number @@ -46,20 +46,20 @@ const Token = Object.freeze({ export class CommaSeparated extends MapAccess implements IIterableAccess { private readonly de: JSONDeserializer - private readonly defaultSeed: GenericSeed + private readonly defaultSeed: GenericSeed private first: boolean = true - constructor(deserializer: JSONDeserializer, visitor: IVisitor = new GenericVisitor()) { + constructor(deserializer: JSONDeserializer, visitor: IVisitor = new ProxyVisitor()) { super() this.de = deserializer this.defaultSeed = new GenericSeed(visitor) } - private seed(): Deserialize { - return this.defaultSeed.deserialize.bind(this.defaultSeed) as Deserialize + private seed(): Deserialize { + return this.defaultSeed.deserialize.bind(this.defaultSeed) as Deserialize } - private nextItemSeed(seed: D, end: number): IteratorResult { + private nextItemSeed>(seed: D, end: number): IteratorResult { if (this.de.buffer.peek().next() === end) { return IterResult.Done() } @@ -75,11 +75,11 @@ export class CommaSeparated extends MapAccess implements IIterableAccess { return IterResult.Next(seed(this.de)) as IteratorResult } - nextKeySeed(seed: K): IteratorResult { + nextKeySeed>(seed: K): IteratorResult { return this.nextItemSeed(seed, Token.RightCurly) } - nextValueSeed(seed: V): IteratorResult { + nextValueSeed>(seed: V): IteratorResult { const next = this.de.buffer.next() if (next !== Token.Colon) { @@ -90,7 +90,7 @@ export class CommaSeparated extends MapAccess implements IIterableAccess { } private nextItem(end: number): IteratorResult { - return this.nextItemSeed(this.seed(), end) + return this.nextItemSeed(this.seed(), end) } nextKey(): IteratorResult { @@ -98,7 +98,7 @@ export class CommaSeparated extends MapAccess implements IIterableAccess { } nextValue(): IteratorResult { - return this.nextValueSeed(this.seed()) + return this.nextValueSeed(this.seed()) } nextElement(): IteratorResult { diff --git a/src/index.ts b/src/index.ts index 43ecfbd..23231dc 100644 --- a/src/index.ts +++ b/src/index.ts @@ -9,7 +9,7 @@ export function toString(value: any): string { return serializer.output } -export function fromString>(value: string, into: D): T { +export function fromString>(value: string, into: any): T { const deserializer = JSONDeserializer.fromString(value) return deserialize(deserializer, into) }