From 7116abb2ee3dddd6f528121659833a9404d8824a Mon Sep 17 00:00:00 2001 From: rowan Date: Thu, 15 May 2025 14:25:30 -0500 Subject: [PATCH] exports --- src/index.ts | 404 +-------------------------------------------------- src/test.ts | 33 ----- 2 files changed, 4 insertions(+), 433 deletions(-) delete mode 100644 src/test.ts diff --git a/src/index.ts b/src/index.ts index acf717a..6f38342 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,400 +1,4 @@ -//export type Nullable = T | undefined -// -//function staticImplements() { -// return (constructor: U) => { constructor } -//} -// -//@staticImplements>() -//class GenericSeed implements Deserialize { -// static deserialize(deserializer: D): T { -// return deserializer.deserializeAny(new GenericVisitor()) -// } -// -// deserialize(deserializer: D): T { -// return GenericSeed.deserialize(deserializer) -// } -//} -// -//class GenericVisitor implements Visitor { -// visitString(value: string): T { -// return value as T -// } -// -// visitNumber(value: number): T { -// return value as T -// } -// -// visitBigInt(value: bigint): T { -// return value as T -// } -// -// visitBoolean(value: boolean): T { -// return value as T -// } -// -// visitSymbol(value: symbol): T { -// return value as T -// } -// -// visitNull(): T { -// return null as T -// } -// -// visitObject(access: MapAccess): T { -// const result: Record = {} -// let entry -// -// while ((entry = access.nextEntry())) { -// result[entry[0]] = entry[1] -// } -// -// return result -// } -// -// visitFunction?(value: Function): T { -// return value as T -// } -// -// visitMap?(access: MapAccess): T { -// const result = new Map() -// let entry -// -// while ((entry = access.nextEntry())) { -// result.set(entry[0], entry[1]) -// } -// -// return result as T -// } -// -// visitIterable?(access: IterableAccess): T { -// const result = new Array(access.sizeHint()) -// let element -// -// while ((element = access.nextElement())) { -// result.push(element) -// } -// -// return result as T -// } -// -// visitClass?(_name: string, _fields: string[], _value: any): T { -// throw new Error("Method not implemented.") -// } -//} -// -//export abstract class MapAccess { -// abstract nextKeySeed>(seed: K): Nullable -// abstract nextValueSeed>(seed: V): Nullable -// -// nextEntrySeed, V extends Deserialize>(kseed: K, vseed: V): Nullable<[TK, TV]> { -// const key = this.nextKeySeed(kseed) as Nullable -// if (key) { -// const value = this.nextValueSeed(vseed) as Nullable -// -// if (value) { -// return [key, value] -// } -// } -// } -// -// nextKey(): Nullable { -// return this.nextValueSeed(GenericSeed) -// } -// -// nextValue(): Nullable { -// return this.nextValueSeed(GenericSeed) -// } -// -// nextEntry(): Nullable<[K, V]> { -// return this.nextEntrySeed(GenericSeed, GenericSeed) -// } -//} -// -//export abstract class IterableAccess { -// abstract nextElementSeed>(seed: I): Nullable -// -// nextElement(): Nullable { -// return this.nextElementSeed(GenericSeed) -// } -// -// sizeHint(): number { return 0 } -//} -// -//export interface ObjectSerializer { -// serializeKey(key: U): T -// serializeValue(value: U): T -// end(): T -//} -// -//export interface IterableSerializer { -// serializeElement(element: U): T -// end(): T -//} -// -//export interface ClassSerializer { -// serializeField(name: PropertyKey, value: U): T -// end(): T -//} -// -//const TypeSerializerMethods = [ -// 'serializeString', -// 'serializeNumber', -// 'serializeBigInt', -// 'serializeBoolean', -// 'serializeSymbol', -// 'serializeMap', -// 'serializeIterable', -// 'serializeNull', -// 'serializeObject', -// 'serializeInstance', -// 'serializeFunction' -//] as const -// -//interface TypeSerializer { -// serializeString(value: string): T -// serializeNumber(value: number): T -// serializeBigInt(value: bigint): T -// serializeBoolean(value: boolean): T -// serializeSymbol(value: Symbol): T -// serializeNull(): T -// serializeObject(): ObjectSerializer -// serializeFunction?(value: Function): T -// serializeMap?(): ObjectSerializer -// serializeIterable?(): IterableSerializer -// serializeClass?(name: PropertyKey): ClassSerializer -//} -// -//const AnySerializerMethods = ['serializeAny'] -// -//interface AnySerializer { -// serializeAny?(value?: any): T -//} -// -//function isGenericSerializer(value: any): boolean { -// return AnySerializerMethods.every(k => isFunction(value[k])) && -// TypeSerializerMethods.every(k => !isFunction(value[k])) -//} -// -//function isPlainObject(value: any): boolean { -// return Object.getPrototypeOf(value) === Object.prototype -//} -// -//function isFunction(value: any): value is Function { -// return value != null && typeof value === 'function' -//} -// -//function isIterable(value: any): value is Iterable { -// return isFunction(value[Symbol.iterator]) -//} -// -//export type Serializer = Partial> & Partial> -// -//export interface Visitor { -// visitString(value: string): T -// visitNumber(value: number): T -// visitBigInt(value: bigint): T -// visitBoolean(value: boolean): T -// visitSymbol(value: symbol): T -// visitNull(): T -// visitObject(value: MapAccess): T -// visitFunction?(value: Function): T -// visitMap?(value: MapAccess): T -// visitIterable?(value: IterableAccess): T -// visitClass?(name: string, fields: string[], value: any): T -//} -// -//export interface Deserializer { -// deserializeAny>(visitor: V): T -// deserializeString>(visitor: V): T -// deserializeNumber>(visitor: V): T -// deserializeBigInt>(visitor: V): T -// deserializeBoolean>(visitor: V): T -// deserializeSymbol>(visitor: V): T -// deserializeNull>(visitor: V): T -// deserializeObject>(visitor: V): T -// deserializeFunction?>(visitor: V): T -// deserializeMap?>(visitor: V): T -// deserializeIterable?>(visitor: V): T -// deserializeClass?>(name: string, fields: string[], visitor: V): T -//} -// -//export type Primitive = string | number | boolean | symbol | bigint | null | undefined -//export interface ToString { -// toString(): string -//} -// -//export interface Serialize { -// serialize>(serializer: S): T -//} -// -//export type Serializable = Primitive | ToString | Serialize -// -//export interface Deserialize { -// deserialize(deserializer: D): T -//} -// -//type Constructor = new (...args: any[]) => object -// -//export const CaseConvention = Object.freeze({ -// Lowercase: 0, -// Uppercase: 1, -// PascalCase: 2, -// CamelCase: 3, -// SnakeCase: 4, -// ScreamingSnakeCase: 5, -// KebabCase: 6, -// ScreamingKebabCase: 7 -//} as const) -// -//export type CaseConvention = typeof CaseConvention[keyof typeof CaseConvention] -// -//function orElse(thisArg: any, a: Nullable, b: Function) { -// return function(...args: any) { -// const fn = a != null ? a : b -// return fn.apply(thisArg, args) -// } -//} -// -//// helper for better ergonomics -//// allows us to capture this, the fallback method, and the args in a closure -//function ifNull(thisArg: any, b: Function, ...args: any) { -// return function(a: Nullable) { -// return orElse(thisArg, a, b).call(thisArg, args) -// } -//} -// -//const unhandledType = (serializer: any, value: any) => new TypeError(`"${serializer.constructor.name}" has no method for value type "${typeof value}"`) -// -//function serializeEntries>(serializer: ObjectSerializer, value: E) { -// let state -// -// for (const [key, val] of value) { -// state = serializer.serializeKey(key) -// state = serializer.serializeValue(val) -// } -// -// return serializer.end() -//} -// -//function serializeObject>(serializer: ObjectSerializer, value: R) { -// return serializeEntries(serializer, Object.entries(value) as Iterable<[K, V]>) -//} -// -//function getClassName(value: any): Nullable { -// return value?.constructor.name -//} -// -//function serializeClass>(serializer: ClassSerializer, value: R) { -// for (const prop in value) { -// serializer.serializeField(prop, value[prop]) -// } -// -// return serializer.end() -//} -// -//function serializeIter>(serializer: IterableSerializer, value: V) { -// let state -// -// for (const val of value) { -// state = serializer.serializeElement(val) -// } -// -// return serializer.end() -//} -// -//// dispatches in the order of serialize -> serializeAny -> throw TypeError -//export function serializeWith(serializer: Serializer, value: Serializable): Nullable { -// // prepare fallback methods -// const serializeAny = orElse( -// serializer, -// serializer.serializeAny, -// (value: Serializable) => unhandledType(serializer, value) -// ) -// -// const serialize = 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 'function': return serialize(serializer.serializeFunction) -// -// case 'object': -// if (value instanceof Map && isFunction(serializer.serializeMap)) { -// return serializeEntries(serializer.serializeMap(), value) -// } else if (isIterable(value) && isFunction(serializer.serializeIterable)) { -// return serializeIter(serializer.serializeIterable(), value) -// } else if (isFunction(serializer.serializeClass) && !isPlainObject(value)) { -// const name = getClassName(value) -// return serializeClass(serializer.serializeClass(name!), value as any) -// } else if (isFunction(serializer.serializeObject)) { -// return serializeObject(serializer.serializeObject!(), value as Record) -// } // deliberate fallthrough when the above fail -// -// default: return serializeAny(value) -// } -//} -// -//export interface SerializationOptions { -// default?: () => T -// rename?: string -// renameAll?: CaseConvention -// tag?: string -// untagged?: boolean -// withInherited?: boolean -//} -// -//const DefaultSerializationOptions: SerializationOptions = { -// withInherited: true -//} -// -//export function serialize(options?: SerializationOptions) { -// options = { -// ...DefaultSerializationOptions, -// ...options -// } -// -// return function (constructor: T) { -// return class Serializable extends constructor implements Serializable { -// static name = constructor.name -// serialize(serializer: Serializer): U { -// // shortcut for serializers with only the serializeAny method -// if (isGenericSerializer(serializer)) { -// return serializer.serializeAny!(this) as U -// } else { -// return serializeWith(serializer, this) as U -// } -// } -// } -// } -//} -// -//export interface DeserializationOptions { -// rename?: string -// renameAll?: CaseConvention -//} -// -//const DefaultDeserializationOptions = { -//} -// -//export function deserialize(options?: DeserializationOptions) { -// options = { -// ...DefaultDeserializationOptions, -// ...options -// } -// -// return function (constructor: C) { -// @staticImplements>() -// class Deserializable extends constructor { -// static deserialize(deserializer: D): T { -// const visitor = new GenericVisitor() -// return deserializer.deserializeAny(visitor) -// } -// } -// -// return Deserializable -// } -//} +export * as ser from './ser' +export * as de from './de' +export * as json from './json' + diff --git a/src/test.ts b/src/test.ts deleted file mode 100644 index 53ae095..0000000 --- a/src/test.ts +++ /dev/null @@ -1,33 +0,0 @@ -import { deserialize } from './de' -import { fromString, toString } from './json' -import { serialize } from './ser' - -const InnerStruct = deserialize()( - @serialize() - class { - c = 'awawa' - }) - -const TestStruct = deserialize()( - @serialize() - class { - a = 1 - b - inner = new InnerStruct() - d = true - e = Math.pow(2, 53) - f = Symbol('test') - g = [1, 'a', [3]] - - constructor() { - this.b = new Map() - this.b.set('test key', 2) - } - }) - -const test = new TestStruct() -const value = toString(test) -console.log(value) -const test2 = fromString(value, TestStruct) -console.log(test2) -