exports
This commit is contained in:
parent
0b3dabddde
commit
7116abb2ee
2 changed files with 4 additions and 433 deletions
404
src/index.ts
404
src/index.ts
|
|
@ -1,400 +1,4 @@
|
|||
//export type Nullable<T> = T | undefined
|
||||
//
|
||||
//function staticImplements<T>() {
|
||||
// return <U extends T>(constructor: U) => { constructor }
|
||||
//}
|
||||
//
|
||||
//@staticImplements<Deserialize<any>>()
|
||||
//class GenericSeed<T> implements Deserialize<T> {
|
||||
// static deserialize<T, D extends Deserializer>(deserializer: D): T {
|
||||
// return deserializer.deserializeAny(new GenericVisitor<T>())
|
||||
// }
|
||||
//
|
||||
// deserialize<D extends Deserializer>(deserializer: D): T {
|
||||
// return GenericSeed.deserialize(deserializer)
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//class GenericVisitor<T> implements Visitor<T> {
|
||||
// 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<PropertyKey, any> = {}
|
||||
// let entry
|
||||
//
|
||||
// while ((entry = access.nextEntry<string, any>())) {
|
||||
// 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<string, any>())) {
|
||||
// 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<T, K extends Deserialize<T>>(seed: K): Nullable<T>
|
||||
// abstract nextValueSeed<T, V extends Deserialize<T>>(seed: V): Nullable<T>
|
||||
//
|
||||
// nextEntrySeed<TK, TV, K extends Deserialize<TK>, V extends Deserialize<TV>>(kseed: K, vseed: V): Nullable<[TK, TV]> {
|
||||
// const key = this.nextKeySeed(kseed) as Nullable<TK>
|
||||
// if (key) {
|
||||
// const value = this.nextValueSeed(vseed) as Nullable<TV>
|
||||
//
|
||||
// if (value) {
|
||||
// return [key, value]
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// nextKey<T>(): Nullable<T> {
|
||||
// return this.nextValueSeed(GenericSeed<T>)
|
||||
// }
|
||||
//
|
||||
// nextValue<T>(): Nullable<T> {
|
||||
// return this.nextValueSeed(GenericSeed<T>)
|
||||
// }
|
||||
//
|
||||
// nextEntry<K, V>(): Nullable<[K, V]> {
|
||||
// return this.nextEntrySeed(GenericSeed<K>, GenericSeed<V>)
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//export abstract class IterableAccess {
|
||||
// abstract nextElementSeed<T, I extends Deserialize<T>>(seed: I): Nullable<T>
|
||||
//
|
||||
// nextElement<T>(): Nullable<T> {
|
||||
// return this.nextElementSeed(GenericSeed<T>)
|
||||
// }
|
||||
//
|
||||
// sizeHint(): number { return 0 }
|
||||
//}
|
||||
//
|
||||
//export interface ObjectSerializer<T = void> {
|
||||
// serializeKey<U extends Serializable>(key: U): T
|
||||
// serializeValue<U extends Serializable>(value: U): T
|
||||
// end(): T
|
||||
//}
|
||||
//
|
||||
//export interface IterableSerializer<T = void> {
|
||||
// serializeElement<U extends Serializable>(element: U): T
|
||||
// end(): T
|
||||
//}
|
||||
//
|
||||
//export interface ClassSerializer<T = void> {
|
||||
// serializeField<U extends Serializable>(name: PropertyKey, value: U): T
|
||||
// end(): T
|
||||
//}
|
||||
//
|
||||
//const TypeSerializerMethods = [
|
||||
// 'serializeString',
|
||||
// 'serializeNumber',
|
||||
// 'serializeBigInt',
|
||||
// 'serializeBoolean',
|
||||
// 'serializeSymbol',
|
||||
// 'serializeMap',
|
||||
// 'serializeIterable',
|
||||
// 'serializeNull',
|
||||
// 'serializeObject',
|
||||
// 'serializeInstance',
|
||||
// 'serializeFunction'
|
||||
//] as const
|
||||
//
|
||||
//interface TypeSerializer<T> {
|
||||
// serializeString(value: string): T
|
||||
// serializeNumber(value: number): T
|
||||
// serializeBigInt(value: bigint): T
|
||||
// serializeBoolean(value: boolean): T
|
||||
// serializeSymbol(value: Symbol): T
|
||||
// serializeNull(): T
|
||||
// serializeObject(): ObjectSerializer<T>
|
||||
// serializeFunction?(value: Function): T
|
||||
// serializeMap?(): ObjectSerializer<T>
|
||||
// serializeIterable?(): IterableSerializer<T>
|
||||
// serializeClass?(name: PropertyKey): ClassSerializer<T>
|
||||
//}
|
||||
//
|
||||
//const AnySerializerMethods = ['serializeAny']
|
||||
//
|
||||
//interface AnySerializer<T> {
|
||||
// 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<any> {
|
||||
// return isFunction(value[Symbol.iterator])
|
||||
//}
|
||||
//
|
||||
//export type Serializer<T> = Partial<TypeSerializer<T>> & Partial<AnySerializer<T>>
|
||||
//
|
||||
//export interface Visitor<T> {
|
||||
// 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<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeString<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeNumber<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeBigInt<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeBoolean<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeSymbol<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeNull<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeObject<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeFunction?<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeMap?<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeIterable?<T, V extends Visitor<T>>(visitor: V): T
|
||||
// deserializeClass?<T, V extends Visitor<T>>(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<T, S extends Serializer<T>>(serializer: S): T
|
||||
//}
|
||||
//
|
||||
//export type Serializable = Primitive | ToString | Serialize
|
||||
//
|
||||
//export interface Deserialize<T> {
|
||||
// deserialize<D extends Deserializer>(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<Function>, 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<Function>) {
|
||||
// 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<T, K extends Serializable, V extends Serializable, E extends Iterable<[K, V]>>(serializer: ObjectSerializer<T>, value: E) {
|
||||
// let state
|
||||
//
|
||||
// for (const [key, val] of value) {
|
||||
// state = serializer.serializeKey(key)
|
||||
// state = serializer.serializeValue(val)
|
||||
// }
|
||||
//
|
||||
// return serializer.end()
|
||||
//}
|
||||
//
|
||||
//function serializeObject<T, K extends PropertyKey, V extends Serializable, R extends Record<K, V>>(serializer: ObjectSerializer<T>, value: R) {
|
||||
// return serializeEntries(serializer, Object.entries(value) as Iterable<[K, V]>)
|
||||
//}
|
||||
//
|
||||
//function getClassName(value: any): Nullable<string> {
|
||||
// return value?.constructor.name
|
||||
//}
|
||||
//
|
||||
//function serializeClass<T, K extends PropertyKey, V extends Serializable, R extends Record<K, V>>(serializer: ClassSerializer<T>, value: R) {
|
||||
// for (const prop in value) {
|
||||
// serializer.serializeField(prop, value[prop])
|
||||
// }
|
||||
//
|
||||
// return serializer.end()
|
||||
//}
|
||||
//
|
||||
//function serializeIter<T, V extends Iterable<any>>(serializer: IterableSerializer<T>, value: V) {
|
||||
// let state
|
||||
//
|
||||
// for (const val of value) {
|
||||
// state = serializer.serializeElement(val)
|
||||
// }
|
||||
//
|
||||
// return serializer.end()
|
||||
//}
|
||||
//
|
||||
//// dispatches in the order of serialize<type> -> serializeAny -> throw TypeError
|
||||
//export function serializeWith<T>(serializer: Serializer<T>, value: Serializable): Nullable<T> {
|
||||
// // 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<PropertyKey, any>)
|
||||
// } // deliberate fallthrough when the above fail
|
||||
//
|
||||
// default: return serializeAny(value)
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//export interface SerializationOptions {
|
||||
// default?: <T>() => 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 <T extends Constructor>(constructor: T) {
|
||||
// return class Serializable extends constructor implements Serializable {
|
||||
// static name = constructor.name
|
||||
// serialize<U>(serializer: Serializer<U>): 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 <T, C extends Constructor>(constructor: C) {
|
||||
// @staticImplements<Deserialize<T>>()
|
||||
// class Deserializable extends constructor {
|
||||
// static deserialize<D extends Deserializer>(deserializer: D): T {
|
||||
// const visitor = new GenericVisitor<T>()
|
||||
// return deserializer.deserializeAny(visitor)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// return Deserializable
|
||||
// }
|
||||
//}
|
||||
export * as ser from './ser'
|
||||
export * as de from './de'
|
||||
export * as json from './json'
|
||||
|
||||
|
|
|
|||
33
src/test.ts
33
src/test.ts
|
|
@ -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)
|
||||
|
||||
Loading…
Add table
Reference in a new issue