Pass parent to computed properties of struct

index.d.ts

@@ -0,0 +1,154 @@
+declare module 'restructure' {
+  export class DecodeStream {
+    buffer: Buffer;
+    view: DataView;
+    pos: number;
+
+    constructor(buffer: Buffer);
+
+    readString(length: number, encoding = 'ascii'): Buffer;
+    readBuffer(length: number): Buffer;
+    // TODO: other read... methods
+  }
+
+  export class EncodeStream {
+    buffer: Buffer;
+    view: DataView;
+    pos: number;
+    length: number;
+
+    constructor(buffer: Buffer);
+
+    writeBuffer(buffer: Buffer): void;
+    writeString(string: string, encoding = 'ascii'): void;
+    // TODO: other write... methods
+
+    fill(val: Buffer, length: number);
+  }
+
+  class Base<T> {
+    constructor(...args: any);
+    fromBuffer(buffer: Buffer): T;
+    toBuffer(value: T): Buffer;
+
+    decode(stream: r.DecodeStream): T;
+    encode(stream: r.EncodeStream, val: T): void;
+    size(): number;
+  }
+  export type BaseType<T> = typeof Base<T>;
+
+  class BufferT extends Base<Buffer> {}
+  export { BufferT as Buffer };
+
+  type BaseOf<T> = T extends Base<infer U> ? U : never;
+
+  export type LengthArray<T, N, R extends T[] = []> = N extends number
+    ? number extends N
+      ? T[]
+      : R['length'] extends N
+      ? R
+      : LengthArray<T, N, [T, ...R]>
+    : T[];
+
+  // TODO: Fix array fo structs with computed properties type
+  export class Array<T, N extends number | string> extends Base<
+    LengthArray<BaseOf<T>, N>
+  > {
+    type: T;
+    length?: N;
+    lengthType?: 'count' | 'bytes';
+
+    constructor(type: T, length?: N, lengthType?: 'count' | 'bytes');
+  }
+  export class Bitfield<T extends Record<string, boolean>> extends Base<T> {}
+
+  export class Boolean extends Base<boolean> {}
+
+  export class Enum<T extends readonly string[]> extends Base<
+    T[number] | number
+  > {
+    constructor(type: Base<number>, options: T);
+  }
+
+  export class LazyArray<T> extends Base<T[]> {}
+
+  class NumberT extends Base<number> {}
+  export { NumberT as Number };
+
+  export class Fixed extends Number<number> {}
+
+  export class Optional<T> extends Base<T | undefined> {
+    constructor(type: Base<T>, condition?: boolean);
+  }
+
+  export class Pointer extends Base<unknown> {}
+
+  export class VoidPointer {
+    constructor(type: any, value: any);
+  }
+
+  export class Reserved extends Base<never> {}
+
+  class StringT extends Base<string> {}
+  export { StringT as String };
+
+  export type StructType<T extends Record<string, unknown>> = {
+    [K in keyof T]: T[K] extends Base<infer U>
+      ? U
+      : T[K] extends () => infer V
+      ? V
+      : T[K];
+  };
+
+  export type StructFields<T extends Record<string, unknown>> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer V
+      ? (
+          this: StructType<Omit<T, K>>,
+          ctx: StructType<Omit<T, K>>,
+          parent: unknown
+        ) => V
+      : T[K];
+  };
+
+  type StructToBuffer<T extends Record<string, unknown>> = StructType<{
+    [K in keyof T as T[K] extends () => unknown ? never : K]: T[K];
+  }>;
+
+  export class Struct<T extends Record<string, unknown>> extends Base<
+    StructType<T>
+  > {
+    fields: StructFields<T>;
+    constructor(fields: StructFields<T>);
+
+    toBuffer(struct: StructToBuffer<T>): Buffer;
+  }
+
+  export class VersionedStruct extends Base<unknown> {}
+
+  export const uint8: NumberT;
+  export const uint16be: NumberT;
+  export const uint16 = uint16be;
+  export const uint16le: NumberT;
+  export const uint24be: NumberT;
+  export const uint24 = uint24be;
+  export const uint24le: NumberT;
+  export const uint32be: NumberT;
+  export const uint32 = uint32be;
+  export const uint32le: NumberT;
+  export const int8: NumberT;
+  export const int16be: NumberT;
+  export const int16 = int16be;
+  export const int16le: NumberT;
+  export const int24be: NumberT;
+  export const int24 = int24be;
+  export const int24le: NumberT;
+  export const int32be: NumberT;
+  export const int32 = int32be;
+  export const int32le: NumberT;
+  export const floatbe: NumberT;
+  export const float = floatbe;
+  export const floatle: NumberT;
+  export const doublebe: NumberT;
+  export const double = doublebe;
+  export const doublele: NumberT;
+}

package.json

@@ -6,6 +6,7 @@
   "main": "./dist/main.cjs",
   "module": "./index.js",
   "source": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     "import": "./index.js",
     "require": "./dist/main.cjs"

src/Struct.js

@@ -9,7 +9,7 @@ export class Struct extends Base {
 
   decode(stream, parent, length = 0) {
     const res = this._setup(stream, parent, length);
-    this._parseFields(stream, res, this.fields);
+    this._parseFields(stream, res, this.fields, parent);
 
     if (this.process != null) {
       this.process.call(res, stream);
@@ -31,12 +31,12 @@ export class Struct extends Base {
     return res;
   }
 
-  _parseFields(stream, res, fields) {
+  _parseFields(stream, res, fields, parent) {
     for (let key in fields) {
       var val;
       const type = fields[key];
       if (typeof type === 'function') {
-        val = type.call(res, res);
+        val = type.call(res, res, parent);
       } else {
         val = type.decode(stream, res);
       }