remove forward.ts

dist/de/index.d.ts

@@ -1,4 +1,3 @@
-export * from './forward';
 export * from './generic';
 export * from './impl';
 export * from './interface';

dist/de/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./forward"), exports);
 __exportStar(require("./generic"), exports);
 __exportStar(require("./impl"), exports);
 __exportStar(require("./interface"), exports);

dist/de/interface.d.ts

@@ -15,6 +15,7 @@ export interface IMapAccess {
 export declare abstract class MapAccess {
     abstract nextKeySeed<T, K extends Deserialize<T>>(seed: K): IteratorResult<T>;
     abstract nextValueSeed<T, V extends Deserialize<T>>(seed: V): IteratorResult<T>;
+    private orDefaultSeed;
     nextEntrySeed<TK, TV, K extends Deserialize<TK>, V extends Deserialize<TV>>(kseed: K, vseed: V): IteratorResult<[TK, TV]>;
     nextKey<T>(): IteratorResult<T>;
     nextValue<V>(): IteratorResult<V>;

dist/de/interface.js

@@ -5,6 +5,9 @@ exports.isVisitor = isVisitor;
 const utils_1 = require("../utils");
 const generic_1 = require("./generic");
 class MapAccess {
+    orDefaultSeed(seed) {
+        return seed || generic_1.GenericSeed.deserialize;
+    }
     nextEntrySeed(kseed, vseed) {
         const key = this.nextKeySeed(kseed);
         if (!key.done) {
@@ -48,9 +51,9 @@ class MapAccess {
             this.nextValueSeed.bind(this, seed));
     }
     entries(kseed, vseed) {
-        return this.generate(kseed == null || vseed == null ?
+        return this.generate(kseed == null && vseed == null ?
             this.nextEntry.bind(this) :
-            this.nextEntrySeed.bind(this, kseed, vseed));
+            this.nextEntrySeed.bind(this, this.orDefaultSeed(kseed), this.orDefaultSeed(vseed)));
     }
     [Symbol.iterator]() {
         return this.entries();

dist/ser/interface.d.ts

@@ -26,12 +26,11 @@ export interface ISerializer<T> {
     serializeString(value: string): T;
     serializeSymbol(value: symbol): T;
     serializeNull(): T;
-    serializeObject(): ISerializeObject<T>;
-    serializeIterable(): ISerializeIterable<T>;
-    serializeClass(name: string): ISerializeObject<T>;
+    serializeIterable(len?: number): ISerializeIterable<T>;
+    serializeObject(len?: number): ISerializeObject<T>;
+    serializeClass(name: string, len?: number): ISerializeObject<T>;
 }
 export declare class Serializer<T> implements ISerializer<T> {
-    serializeIterable(): ISerializeIterable<T>;
     serializeAny(_value: any): T;
     serializeBoolean(_value: boolean): T;
     serializeNumber(_value: number): T;
@@ -39,8 +38,9 @@ export declare class Serializer<T> implements ISerializer<T> {
     serializeString(_value: string): T;
     serializeSymbol(_value: symbol): T;
     serializeNull(): T;
-    serializeObject(): ISerializeObject<T>;
-    serializeClass(_name: string): ISerializeObject<T>;
+    serializeIterable(_len: number): ISerializeIterable<T>;
+    serializeObject(_len: number): ISerializeObject<T>;
+    serializeClass(_name: string, _len: number): ISerializeObject<T>;
 }
 export interface Serialize<T, U> {
     (serializer: ISerializer<T>, value: U): T;

dist/ser/interface.js

@@ -12,9 +12,6 @@ class SerializeIterable {
 }
 exports.SerializeIterable = SerializeIterable;
 class Serializer {
-    serializeIterable() {
-        throw new Error("Method not implemented.");
-    }
     serializeAny(_value) {
         throw new Error("Method not implemented.");
     }
@@ -36,10 +33,13 @@ class Serializer {
     serializeNull() {
         throw new Error('Method not implemented.');
     }
-    serializeObject() {
+    serializeIterable(_len) {
+        throw new Error("Method not implemented.");
+    }
+    serializeObject(_len) {
         throw new Error('Method not implemented.');
     }
-    serializeClass(_name) {
+    serializeClass(_name, _len) {
         throw new Error('Method not implemented.');
     }
 }

src/de/forward.ts

@@ -1,118 +0,0 @@
-import { IterResult } from '../utils'
-import { Deserialize, IDeserializer, IterableAccess, IVisitor, MapAccess } from './interface'
-
-export class ForwardMapAccess extends MapAccess {
-  private readonly _keys: string[]
-  private readonly _values: any[]
-
-  private kindex: number = 0
-  private vindex: number = 0
-
-  constructor(keys: string[], values: any[]) {
-    super()
-    this._keys = keys
-    this._values = values
-  }
-
-  static fromObject(obj: object): ForwardMapAccess {
-    return new ForwardMapAccess(
-      Object.keys(obj),
-      Object.values(obj)
-    )
-  }
-
-  nextKeySeed<T, K extends Deserialize<T>>(_seed: K): IteratorResult<T> {
-    return this.nextKey()
-  }
-
-  nextValueSeed<T, V extends Deserialize<T>>(_seed: V): IteratorResult<T> {
-    return this.nextValue()
-  }
-
-  nextKey<T>(): IteratorResult<T> {
-    if (this.kindex < this.keys.length) {
-      return IterResult.Next(this._keys[this.kindex++]) as IteratorResult<T>
-    } else {
-      return IterResult.Done()
-    }
-  }
-
-  nextValue<V>(): IteratorResult<V> {
-    if (this.vindex < this.values.length) {
-      return IterResult.Next(this._values[this.vindex++]) as IteratorResult<V>
-    } else {
-      return IterResult.Done()
-    }
-  }
-}
-
-export class ForwardIterableAccess extends IterableAccess {
-  private readonly items: any[]
-  private index: number = 0
-
-  constructor(items: any[]) {
-    super()
-    this.items = items
-  }
-
-  nextElement<T>(): IteratorResult<T> {
-    if (this.index < this.items.length) {
-      return IterResult.Next(this.items[this.index++]) as IteratorResult<T>
-    } else {
-      return IterResult.Done()
-    }
-  }
-}
-
-export class Forward implements IDeserializer {
-  private readonly value: any
-
-  constructor(value: any) {
-    this.value = value
-  }
-
-  static with(value: any): Forward {
-    return new this(value)
-  }
-
-  deserializeAny<T, V extends IVisitor<T>>(_visitor: V): T {
-    throw new Error("Can't forward to deserializeAny")
-  }
-
-  deserializeBoolean<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitBoolean(this.value)
-  }
-
-  deserializeNumber<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitNumber(this.value)
-  }
-
-  deserializeBigInt<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitBigInt(this.value)
-  }
-
-  deserializeString<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitString(this.value)
-  }
-
-  deserializeSymbol<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitSymbol(this.value)
-  }
-
-  deserializeNull<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitNull()
-  }
-
-  deserializeObject<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitObject(ForwardMapAccess.fromObject(this.value))
-  }
-
-  deserializeIterable<T, V extends IVisitor<T>>(visitor: V): T {
-    return visitor.visitIterable(new ForwardIterableAccess(this.value))
-  }
-
-  deserializeFunction<T, V extends IVisitor<T>>(_visitor: V): T {
-    throw new Error('Method not implemented.')
-  }
-}
-

src/de/index.ts

@@ -1,4 +1,3 @@
-export * from './forward'
 export * from './generic'
 export * from './impl'
 export * from './interface'