@isopodlabs/binary_libs 1.3.0 → 1.4.0

package/dist/CompoundDocument.d.ts

@@ -1,26 +1,43 @@
 import * as bin from '@isopodlabs/binary';
-declare class FAT {
+export interface Backing {
+    readAt(offset: number, data: Uint8Array): Promise<number>;
+    writeAt(offset: number, data: Uint8Array): Promise<void>;
+}
+export declare class Sectors {
     shift: number;
-    sectors: Uint8Array;
-    fat: Int32Array;
+    private offset;
+    private backing?;
+    sectors: Uint8Array[];
+    dirty: Set<number>;
+    constructor(shift: number, offset?: number, backing?: Backing | undefined);
+    size(): number;
+    sector(id: number): Promise<Uint8Array>;
+    dirty_sector(id: number): Promise<Uint8Array>;
+    writeHeader(data: Uint8Array): Promise<void>;
+    flush(): Promise<void>;
+}
+declare class FAT {
+    fat: TypedArray<number>;
+    fat_shift: number;
+    data: Sectors;
     freed: number[];
-    dirty_fat: Set<number>;
-    dirty_sec: Set<number>;
-    constructor(size: number, shift: number, sectors: Uint8Array);
+    dirty: Set<number>;
+    constructor(fat: bin.utils.TypedArray<number>, fat_shift: number, data: Sectors);
     private free;
-    private alloc;
+    alloc(type: number): number;
     get_chain(id: number): number[];
     resize_chain(chain: number[], data_size: number): void;
     clear_dirty(): void;
-    read_chain(chain: number[], dest: Uint8Array): void;
-    read_chain_alloc(chain: number[]): Uint8Array;
-    read(id: number, dest: Uint8Array): void;
-    write_chain(chain: number[], source: Uint8Array): void;
-    dirty_chain_part(chain: number[], offset: number): Uint8Array;
+    sector(id: number): Promise<Uint8Array | null>;
+    chain_part(chain: number[], offset: number): Promise<Uint8Array | undefined>;
+    dirty_sector(id: number): Promise<Uint8Array | null>;
+    dirty_chain_part(chain: number[], offset: number): Promise<Uint8Array | undefined>;
+    read_chain(chain: number[], dest: Uint8Array): Promise<void>;
+    write_chain(chain: number[], source: Uint8Array): Promise<void>;
+    write(id: number, source: Uint8Array): Promise<number>;
 }
-declare const Header_base: (new (s: bin._stream) => {
-    magic: bigint;
-    id: Uint8Array;
+declare const Header_base: (new (s: bin._stream | {
+    id: any;
     revision: number;
     version: number;
     byteorder: number;
@@ -30,29 +47,77 @@ declare const Header_base: (new (s: bin._stream) => {
     num_directory: number;
     num_fat: number;
     first_directory: number;
-    transaction: void;
     mini_cutoff: number;
     first_mini: number;
     num_mini: number;
     first_difat: number;
     num_difat: number;
-    difat: Uint8Array;
+    difat: Int32Array;
+}) => {
+    id: any;
+    revision: number;
+    version: number;
+    byteorder: number;
+    sector_shift: number;
+    mini_shift: number;
+    unused1: void;
+    num_directory: number;
+    num_fat: number;
+    first_directory: number;
+    mini_cutoff: number;
+    first_mini: number;
+    num_mini: number;
+    first_difat: number;
+    num_difat: number;
+    difat: Int32Array;
 } & {
     write(w: bin._stream): void;
-}) & {
-    get: <X extends abstract new (...args: any) => any>(this: X, s: bin._stream) => InstanceType<X>;
-    put: (s: bin._stream, v: any) => void;
-};
+}) & bin.WithStaticGet & bin.WithStaticPut;
 export declare class Header extends Header_base {
     sector_size(): number;
     use_mini(size: number): boolean;
-    valid(): boolean;
 }
-declare const DirEntry_base: (new (s: bin._stream) => {
+declare class Master {
+    header: Header;
+    fat: FAT;
+    mini_fat: FAT;
+    fat_chain: number[];
+    difat_chain: number[];
+    static load<T extends Master>(this: new (...args: any[]) => T, header: Header, sectors: Sectors): Promise<T>;
+    constructor(header: Header, fat: FAT, mini_fat: FAT, fat_chain: number[], difat_chain: number[]);
+    get_fat(mini: boolean): FAT;
+    flush(dirty_header?: boolean): Promise<void>;
+}
+export declare const TYPE: {
+    readonly Empty: 0;
+    readonly UserStorage: 1;
+    readonly UserStream: 2;
+    readonly LockBytes: 3;
+    readonly Property: 4;
+    readonly RootStorage: 5;
+};
+type TYPE = 0 | 1 | 2 | 3 | 4 | 5;
+type COLOUR = 0 | 1;
+declare const DirEntry_base: new (contents: {
     name: string;
     name_size: number;
-    type: number;
-    colour: number;
+    type: TYPE;
+    colour: COLOUR;
+    left: number;
+    right: number;
+    root: number;
+    guid: Uint8Array;
+    flags: number;
+    creation: bigint;
+    modification: bigint;
+    sec_id: number;
+    size: number;
+    unused: number;
+}) => {
+    name: string;
+    name_size: number;
+    type: TYPE;
+    colour: COLOUR;
     left: number;
     right: number;
     root: number;
@@ -63,33 +128,76 @@ declare const DirEntry_base: (new (s: bin._stream) => {
     sec_id: number;
     size: number;
     unused: number;
-} & {
-    write(w: bin._stream): void;
-}) & {
-    get: <X extends abstract new (...args: any) => any>(this: X, s: bin._stream) => InstanceType<X>;
-    put: (s: bin._stream, v: any) => void;
 };
-declare class DirEntry extends DirEntry_base {
-    index: number;
-    constructor(index: number, r: bin.stream);
-    load(fat: FAT): Uint8Array;
+export declare class DirEntry extends DirEntry_base {
+    reader: Reader;
+    dir?: Directory;
+    constructor(reader: Reader, contents: {
+        name: string;
+        name_size: number;
+        type: TYPE;
+        colour: COLOUR;
+        left: number;
+        right: number;
+        root: number;
+        guid: Uint8Array;
+        flags: number;
+        creation: bigint;
+        modification: bigint;
+        sec_id: number;
+        size: number;
+        unused: number;
+    });
+    static reader(reader: Reader): {
+        get: (s: bin._stream) => DirEntry;
+        put: (s: bin._stream, entry: DirEntry) => void;
+    };
+    is(type: 0): this is DirEntry;
+    is(type: 1): this is Directory;
+    is(type: 2): this is Stream;
+    is(type: 3): this is DirEntry;
+    is(type: 4): this is DirEntry;
+    is(type: 5): this is Directory;
+    is_directory(): this is Directory;
+    is_data(): this is Stream;
+    rename(name: string): void;
+    remove(): void;
 }
-declare class Master {
-    header: Header;
-    difat: Int32Array;
-    fat: FAT;
-    mini_fat: FAT;
-    mini_chain: number[];
-    constructor(sectors: Uint8Array, header: Header);
-    get_fat(mini: boolean): FAT;
-    flush(filename: string): Promise<void>;
+export declare class Directory extends DirEntry {
+    find(name: string): DirEntry | undefined;
+    entries(): Generator<DirEntry, any, unknown>;
+    private _addEntry;
+    addEntry(name: string, type: 0): DirEntry;
+    addEntry(name: string, type: 1): Directory;
+    addEntry(name: string, type: 2): Stream;
+    addEntry(name: string, type: 3): DirEntry;
+    addEntry(name: string, type: 4): DirEntry;
+    addEntry(name: string, type: 5): Directory;
+    addStream(name: string, data: Uint8Array): Promise<void>;
+}
+export declare class Stream extends DirEntry {
+    read(): Promise<Uint8Array>;
+    write(data: Uint8Array): Promise<void>;
 }
 export declare class Reader extends Master {
     entries: DirEntry[];
-    private entry_chain;
-    constructor(sectors: Uint8Array, header: Header);
-    find(name: string, i?: number): DirEntry | undefined;
-    read(e: DirEntry): Uint8Array;
-    write(e: DirEntry, data: Uint8Array): void;
+    chain: number[];
+    pending: Promise<void>;
+    free: number;
+    static loadBacking(backing: Backing): Promise<Reader>;
+    static loadBuffer(buffer: Buffer): Promise<Reader>;
+    static load1(me: Reader): Promise<Reader>;
+    get root(): Directory;
+    updateIndex(index: number): Promise<void>;
+    updateEntry(entry: DirEntry): Promise<void>;
+    clearEntry(index: number): Promise<void>;
+    addEntry(entry: DirEntry): number;
+    rbFind(root: number, name: string): readonly [number, number];
+    rbInsert(root: DirEntry, entry: DirEntry): number;
+    rbRemove(root: DirEntry, entry: DirEntry): void;
+    find(name: string, create?: boolean): DirEntry | undefined;
+    read(entry: DirEntry): Promise<Uint8Array>;
+    write(entry: DirEntry, data: Uint8Array): Promise<void>;
+    flush(): Promise<void>;
 }
 export {};