@configura/web-core 2.1.0-alpha.0 → 2.1.0-alpha.2

package/dist/cm/format/dex/DexInt.js

@@ -1,18 +1,18 @@
-export class DexInt {
-    constructor(value) {
-        this.value = value;
-    }
-    toString() {
-        return `DexInt(${this.value})`;
-    }
-}
-// TODO: is this correct at all?
-export class DexInt64 {
-    constructor(high, low) {
-        this.high = high;
-        this.low = low;
-    }
-    toString() {
-        return `DexInt(${this.high}, ${this.low})`;
-    }
-}
+export class DexInt {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return `DexInt(${this.value})`;
+    }
+}
+// TODO: is this correct at all?
+export class DexInt64 {
+    constructor(high, low) {
+        this.high = high;
+        this.low = low;
+    }
+    toString() {
+        return `DexInt(${this.high}, ${this.low})`;
+    }
+}

package/dist/cm/format/dex/DexInternalizedXRef.d.ts

@@ -1,20 +1,20 @@
-import { DexReader } from "./DexReader.js";
-import { DexXRefStyle } from "./DexXRef.js";
-export declare class DexInternalizedXRef {
-    id: number;
-    xrefCount: number;
-    pos: number;
-    fileSize: number;
-    url: string;
-    hashId: string;
-    encoding: string;
-    hash: string;
-    localFileCreated: boolean;
-    style: DexXRefStyle;
-    constructor(id: number, xrefCount: number, pos: number, fileSize: number, url: string, style: string, hashId: string, encoding: string, hash: string);
-    target(): string;
-    xrefStyle(): DexXRefStyle;
-    createLocalFile(reader: DexReader): string;
-    toString(): string;
-}
+import { DexReader } from "./DexReader.js";
+import { DexXRefStyle } from "./DexXRef.js";
+export declare class DexInternalizedXRef {
+    id: number;
+    xrefCount: number;
+    pos: number;
+    fileSize: number;
+    url: string;
+    hashId: string;
+    encoding: string;
+    hash: string;
+    localFileCreated: boolean;
+    style: DexXRefStyle;
+    constructor(id: number, xrefCount: number, pos: number, fileSize: number, url: string, style: string, hashId: string, encoding: string, hash: string);
+    target(): string;
+    xrefStyle(): DexXRefStyle;
+    createLocalFile(reader: DexReader): string;
+    toString(): string;
+}
 //# sourceMappingURL=DexInternalizedXRef.d.ts.map

package/dist/cm/format/dex/DexInternalizedXRef.js

@@ -1,65 +1,65 @@
-import { DexReader } from "./DexReader.js";
-import { DexXRefStyle } from "./DexXRef.js";
-export class DexInternalizedXRef {
-    constructor(id, xrefCount, pos, fileSize, url, style, hashId, encoding, hash) {
-        this.id = id;
-        this.xrefCount = xrefCount;
-        this.pos = pos;
-        this.fileSize = fileSize;
-        this.url = url;
-        this.hashId = hashId;
-        this.encoding = encoding;
-        this.hash = hash;
-        this.localFileCreated = false;
-        switch (style) {
-            case "anonymous":
-                this.style = DexXRefStyle.Anonymous;
-                break;
-            case "internal":
-                this.style = DexXRefStyle.Internal;
-                break;
-            case "external":
-                this.style = DexXRefStyle.External;
-                break;
-            default:
-                throw new Error("[DexInternalizedXRef] invalid style: " + style);
-        }
-    }
-    target() {
-        switch (this.style) {
-            case DexXRefStyle.Anonymous: {
-                const filename = this.url.slice(this.url.lastIndexOf("/") + 1);
-                return this.hash + "." + this.hashId + "." + this.encoding + "." + filename;
-            }
-            case DexXRefStyle.Internal:
-                return this.url;
-            default:
-                throw Error("[DexInternalizedXRef.target] invalid style: " + this.style);
-        }
-    }
-    xrefStyle() {
-        return this.style;
-    }
-    // Desktop implementation returns url to new file on disk
-    // Instead return a buffer here
-    // TODO: let the reader take care of this
-    createLocalFile(reader) {
-        const manager = reader.manager;
-        let url = manager.xrefTarget(this);
-        url = manager.expandRoot(url);
-        if (this.localFileCreated) {
-            return url;
-        }
-        if (!reader.isOpen) {
-            throw Error("reader not open");
-        }
-        const slice = reader.readInternalizedXRefFile(this.pos, this.fileSize);
-        // TODO: verify hash
-        new DexReader(slice, reader.manager, url);
-        this.localFileCreated = true;
-        return url;
-    }
-    toString() {
-        return `DexInternalizedXRef()`;
-    }
-}
+import { DexReader } from "./DexReader.js";
+import { DexXRefStyle } from "./DexXRef.js";
+export class DexInternalizedXRef {
+    constructor(id, xrefCount, pos, fileSize, url, style, hashId, encoding, hash) {
+        this.id = id;
+        this.xrefCount = xrefCount;
+        this.pos = pos;
+        this.fileSize = fileSize;
+        this.url = url;
+        this.hashId = hashId;
+        this.encoding = encoding;
+        this.hash = hash;
+        this.localFileCreated = false;
+        switch (style) {
+            case "anonymous":
+                this.style = DexXRefStyle.Anonymous;
+                break;
+            case "internal":
+                this.style = DexXRefStyle.Internal;
+                break;
+            case "external":
+                this.style = DexXRefStyle.External;
+                break;
+            default:
+                throw new Error("[DexInternalizedXRef] invalid style: " + style);
+        }
+    }
+    target() {
+        switch (this.style) {
+            case DexXRefStyle.Anonymous: {
+                const filename = this.url.slice(this.url.lastIndexOf("/") + 1);
+                return this.hash + "." + this.hashId + "." + this.encoding + "." + filename;
+            }
+            case DexXRefStyle.Internal:
+                return this.url;
+            default:
+                throw Error("[DexInternalizedXRef.target] invalid style: " + this.style);
+        }
+    }
+    xrefStyle() {
+        return this.style;
+    }
+    // Desktop implementation returns url to new file on disk
+    // Instead return a buffer here
+    // TODO: let the reader take care of this
+    createLocalFile(reader) {
+        const manager = reader.manager;
+        let url = manager.xrefTarget(this);
+        url = manager.expandRoot(url);
+        if (this.localFileCreated) {
+            return url;
+        }
+        if (!reader.isOpen) {
+            throw Error("reader not open");
+        }
+        const slice = reader.readInternalizedXRefFile(this.pos, this.fileSize);
+        // TODO: verify hash
+        new DexReader(slice, reader.manager, url);
+        this.localFileCreated = true;
+        return url;
+    }
+    toString() {
+        return `DexInternalizedXRef()`;
+    }
+}

package/dist/cm/format/dex/DexLoader.d.ts

@@ -1,9 +1,9 @@
-import { DexReader, DexSerializable } from "./DexReader.js";
-import { DexURL } from "./DexURL.js";
-export declare class DexLoader {
-    load(reader: DexReader, url: string, path?: string): DexSerializable;
-}
-export declare class DexGmImageLoader extends DexLoader {
-    load(reader: DexReader, url: string, path?: string): DexURL;
-}
+import { DexReader, DexSerializable } from "./DexReader.js";
+import { DexURL } from "./DexURL.js";
+export declare class DexLoader {
+    load(reader: DexReader, url: string, path?: string): DexSerializable;
+}
+export declare class DexGmImageLoader extends DexLoader {
+    load(reader: DexReader, url: string, path?: string): DexURL;
+}
 //# sourceMappingURL=DexLoader.d.ts.map

package/dist/cm/format/dex/DexLoader.js

@@ -1,12 +1,12 @@
-import { DexURL } from "./DexURL.js";
-// tslint:disable:max-classes-per-file
-export class DexLoader {
-    load(reader, url, path) {
-        throw Error("default loader not implemented");
-    }
-}
-export class DexGmImageLoader extends DexLoader {
-    load(reader, url, path) {
-        return new DexURL(url);
-    }
-}
+import { DexURL } from "./DexURL.js";
+// tslint:disable:max-classes-per-file
+export class DexLoader {
+    load(reader, url, path) {
+        throw Error("default loader not implemented");
+    }
+}
+export class DexGmImageLoader extends DexLoader {
+    load(reader, url, path) {
+        return new DexURL(url);
+    }
+}

package/dist/cm/format/dex/DexManager.d.ts

@@ -1,21 +1,21 @@
-import { Logger } from "@configura/web-utilities";
-import { DexInternalizedXRef } from "./DexInternalizedXRef.js";
-import { DexLoader } from "./DexLoader.js";
-import { DexObj } from "./DexObj.js";
-import { DexReader } from "./DexReader.js";
-import { DexXRefTargetFilter } from "./DexXRefTargetFilter.js";
-export declare class DexManager {
-    id: string;
-    urlRoots?: Map<string, string> | undefined;
-    xrefTargetFilter: DexXRefTargetFilter;
-    readers: Map<string, DexReader>;
-    loaders: Map<string, DexLoader>;
-    constructor(id: string, urlRoots?: Map<string, string> | undefined, xrefTargetFilter?: DexXRefTargetFilter, readers?: Map<string, DexReader>, defaultLoaders?: boolean);
-    expandRoot(url: string): string;
-    xrefTarget(ref: DexInternalizedXRef): string;
-    loader(suffix: string): DexLoader | undefined;
-    defaultLoaders(): void;
-    load(logger: Logger, url: string, abortSignal?: AbortSignal): Promise<DexObj>;
-    arrayBufferToDexObj(logger: Logger, url: string, buffer: ArrayBuffer): DexObj;
-}
+import { Logger } from "@configura/web-utilities";
+import { DexInternalizedXRef } from "./DexInternalizedXRef.js";
+import { DexLoader } from "./DexLoader.js";
+import { DexObj } from "./DexObj.js";
+import { DexReader } from "./DexReader.js";
+import { DexXRefTargetFilter } from "./DexXRefTargetFilter.js";
+export declare class DexManager {
+    id: string;
+    urlRoots?: Map<string, string> | undefined;
+    xrefTargetFilter: DexXRefTargetFilter;
+    readers: Map<string, DexReader>;
+    loaders: Map<string, DexLoader>;
+    constructor(id: string, urlRoots?: Map<string, string> | undefined, xrefTargetFilter?: DexXRefTargetFilter, readers?: Map<string, DexReader>, defaultLoaders?: boolean);
+    expandRoot(url: string): string;
+    xrefTarget(ref: DexInternalizedXRef): string;
+    loader(suffix: string): DexLoader | undefined;
+    defaultLoaders(): void;
+    load(logger: Logger, url: string, abortSignal?: AbortSignal): Promise<DexObj>;
+    arrayBufferToDexObj(logger: Logger, url: string, buffer: ArrayBuffer): DexObj;
+}
 //# sourceMappingURL=DexManager.d.ts.map

package/dist/cm/format/dex/DexManager.js

@@ -1,78 +1,78 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { DexGmImageLoader } from "./DexLoader.js";
-import { DexObj } from "./DexObj.js";
-import { DexReader } from "./DexReader.js";
-import { DexXRefTargetFilter } from "./DexXRefTargetFilter.js";
-export class DexManager {
-    constructor(id, urlRoots, xrefTargetFilter = new DexXRefTargetFilter(), readers = new Map(), defaultLoaders = true) {
-        this.id = id;
-        this.urlRoots = urlRoots;
-        this.xrefTargetFilter = xrefTargetFilter;
-        this.readers = readers;
-        this.loaders = new Map();
-        if (defaultLoaders) {
-            this.defaultLoaders();
-        }
-    }
-    expandRoot(url) {
-        if (this.urlRoots === undefined) {
-            return url;
-        }
-        for (const [key, value] of this.urlRoots.entries()) {
-            url = url.replace(key, value);
-        }
-        return url;
-    }
-    xrefTarget(ref) {
-        return this.xrefTargetFilter.target(ref);
-    }
-    loader(suffix) {
-        return this.loaders.get(suffix);
-    }
-    defaultLoaders() {
-        const suffixes = ["jpg", "jpeg", "bmp", "png", "cmmips"];
-        const loader = new DexGmImageLoader();
-        for (const suffix of suffixes) {
-            this.loaders.set(suffix, loader);
-        }
-    }
-    load(logger, url, abortSignal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {};
-            if (abortSignal) {
-                params.signal = abortSignal;
-            }
-            const response = yield fetch(url, params);
-            if (!response.ok) {
-                logger.error(response);
-                throw logger.errorAsObject("response not OK!");
-            }
-            const buffer = yield response.arrayBuffer();
-            return this.arrayBufferToDexObj(logger, url, buffer);
-        });
-    }
-    arrayBufferToDexObj(logger, url, buffer) {
-        const slice = new Uint8Array(buffer);
-        const reader = new DexReader(slice, this, url);
-        try {
-            reader.begin();
-            const root = reader.readRoot();
-            if (!(root instanceof DexObj)) {
-                throw logger.errorAsObject("root: is not DexObj", root);
-            }
-            return root;
-        }
-        catch (e) {
-            logger.errorFromCaught(e);
-            throw typeof e === "string" ? Error(e) : e;
-        }
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DexGmImageLoader } from "./DexLoader.js";
+import { DexObj } from "./DexObj.js";
+import { DexReader } from "./DexReader.js";
+import { DexXRefTargetFilter } from "./DexXRefTargetFilter.js";
+export class DexManager {
+    constructor(id, urlRoots, xrefTargetFilter = new DexXRefTargetFilter(), readers = new Map(), defaultLoaders = true) {
+        this.id = id;
+        this.urlRoots = urlRoots;
+        this.xrefTargetFilter = xrefTargetFilter;
+        this.readers = readers;
+        this.loaders = new Map();
+        if (defaultLoaders) {
+            this.defaultLoaders();
+        }
+    }
+    expandRoot(url) {
+        if (this.urlRoots === undefined) {
+            return url;
+        }
+        for (const [key, value] of this.urlRoots.entries()) {
+            url = url.replace(key, value);
+        }
+        return url;
+    }
+    xrefTarget(ref) {
+        return this.xrefTargetFilter.target(ref);
+    }
+    loader(suffix) {
+        return this.loaders.get(suffix);
+    }
+    defaultLoaders() {
+        const suffixes = ["jpg", "jpeg", "bmp", "png", "cmmips"];
+        const loader = new DexGmImageLoader();
+        for (const suffix of suffixes) {
+            this.loaders.set(suffix, loader);
+        }
+    }
+    load(logger, url, abortSignal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {};
+            if (abortSignal) {
+                params.signal = abortSignal;
+            }
+            const response = yield fetch(url, params);
+            if (!response.ok) {
+                logger.error(response);
+                throw logger.errorAsObject("response not OK!");
+            }
+            const buffer = yield response.arrayBuffer();
+            return this.arrayBufferToDexObj(logger, url, buffer);
+        });
+    }
+    arrayBufferToDexObj(logger, url, buffer) {
+        const slice = new Uint8Array(buffer);
+        const reader = new DexReader(slice, this, url);
+        try {
+            reader.begin();
+            const root = reader.readRoot();
+            if (!(root instanceof DexObj)) {
+                throw logger.errorAsObject("root: is not DexObj", root);
+            }
+            return root;
+        }
+        catch (e) {
+            logger.errorFromCaught(e);
+            throw typeof e === "string" ? Error(e) : e;
+        }
+    }
+}

package/dist/cm/format/dex/DexObj.d.ts

@@ -1,16 +1,16 @@
-import { DexReader, DexSerializable } from "./DexReader.js";
-export declare class DexObj {
-    type?: string | undefined;
-    id?: string | undefined;
-    props: Map<string, DexSerializable>;
-    reader?: DexReader | undefined;
-    static cast(obj: unknown): DexObj | undefined;
-    static fcast(obj: unknown): DexObj;
-    static withReader(reader: DexReader): DexObj;
-    constructor(type?: string | undefined, id?: string | undefined, props?: Map<string, DexSerializable>, reader?: DexReader | undefined);
-    put(key: string, value: DexSerializable): void;
-    has(key: string): boolean;
-    get(key: string): DexSerializable;
-    loadAll(visited?: DexObj[]): Error | undefined;
-}
+import { DexReader, DexSerializable } from "./DexReader.js";
+export declare class DexObj {
+    type?: string | undefined;
+    id?: string | undefined;
+    props: Map<string, DexSerializable>;
+    reader?: DexReader | undefined;
+    static cast(obj: unknown): DexObj | undefined;
+    static fcast(obj: unknown): DexObj;
+    static withReader(reader: DexReader): DexObj;
+    constructor(type?: string | undefined, id?: string | undefined, props?: Map<string, DexSerializable>, reader?: DexReader | undefined);
+    put(key: string, value: DexSerializable): void;
+    has(key: string): boolean;
+    get(key: string): DexSerializable;
+    loadAll(visited?: DexObj[]): Error | undefined;
+}
 //# sourceMappingURL=DexObj.d.ts.map

package/dist/cm/format/dex/DexObj.js

@@ -1,86 +1,86 @@
-import { DexRef } from "./DexRef.js";
-export class DexObj {
-    constructor(type, id, props = new Map(), reader) {
-        this.type = type;
-        this.id = id;
-        this.props = props;
-        this.reader = reader;
-    }
-    static cast(obj) {
-        if (obj instanceof DexObj) {
-            return obj;
-        }
-    }
-    static fcast(obj) {
-        if (obj instanceof DexObj) {
-            return obj;
-        }
-        throw Error(`obj: ${obj} not DexObj`);
-    }
-    static withReader(reader) {
-        return new this(undefined, undefined, undefined, reader);
-    }
-    // dexType() {
-    // 	return DexTypeId.DexObj;
-    // }
-    // manager(): DexManager | undefined {
-    // 	return this.reader ? this.reader.manager : undefined;
-    // }
-    put(key, value) {
-        this.props.set(key, value);
-    }
-    has(key) {
-        return this.props.get(key) !== undefined;
-    }
-    // _getPath(paths: string[]) {
-    // 	let entity: DexEntity | undefined = this;
-    // 	for (const path of paths) {
-    // 		const a: DexObj | undefined = entity instanceof DexObj ? entity : undefined;
-    // 		if (!a) {
-    // 			return;
-    // 		}
-    // 		const entityAtPath = a.get(path);
-    // 		if (entityAtPath instanceof DexEntity) {
-    // 			entity = entityAtPath;
-    // 		}
-    // 	}
-    // 	return entity;
-    // }
-    // getPathFromPaths(paths: string[]) {
-    // 	return this._getPath(paths);
-    // }
-    // getPath(k: string) {
-    // 	const delimiter = ".";
-    // 	if (k.slice(0, 1) === delimiter) {
-    // 		return Error("[DexObj.getPath] path may not begin with a delimiter");
-    // 	}
-    // 	return this._getPath(k.split(delimiter));
-    // }
-    get(key) {
-        // if (this.reader) {
-        // 	this.reader.setAccessed();
-        // }
-        const entity = this.props.get(key);
-        if (entity instanceof DexRef) {
-            const value = entity.load(key);
-            this.props.set(key, value);
-            return value;
-        }
-        return entity;
-    }
-    loadAll(visited = []) {
-        if (visited.indexOf(this) !== -1) {
-            return;
-        }
-        visited.push(this);
-        for (const key of this.props.keys()) {
-            const entity = this.get(key);
-            if (entity instanceof Error) {
-                return entity;
-            }
-            else if (entity instanceof DexObj) {
-                entity.loadAll(visited);
-            }
-        }
-    }
-}
+import { DexRef } from "./DexRef.js";
+export class DexObj {
+    constructor(type, id, props = new Map(), reader) {
+        this.type = type;
+        this.id = id;
+        this.props = props;
+        this.reader = reader;
+    }
+    static cast(obj) {
+        if (obj instanceof DexObj) {
+            return obj;
+        }
+    }
+    static fcast(obj) {
+        if (obj instanceof DexObj) {
+            return obj;
+        }
+        throw Error(`obj: ${obj} not DexObj`);
+    }
+    static withReader(reader) {
+        return new this(undefined, undefined, undefined, reader);
+    }
+    // dexType() {
+    // 	return DexTypeId.DexObj;
+    // }
+    // manager(): DexManager | undefined {
+    // 	return this.reader ? this.reader.manager : undefined;
+    // }
+    put(key, value) {
+        this.props.set(key, value);
+    }
+    has(key) {
+        return this.props.get(key) !== undefined;
+    }
+    // _getPath(paths: string[]) {
+    // 	let entity: DexEntity | undefined = this;
+    // 	for (const path of paths) {
+    // 		const a: DexObj | undefined = entity instanceof DexObj ? entity : undefined;
+    // 		if (!a) {
+    // 			return;
+    // 		}
+    // 		const entityAtPath = a.get(path);
+    // 		if (entityAtPath instanceof DexEntity) {
+    // 			entity = entityAtPath;
+    // 		}
+    // 	}
+    // 	return entity;
+    // }
+    // getPathFromPaths(paths: string[]) {
+    // 	return this._getPath(paths);
+    // }
+    // getPath(k: string) {
+    // 	const delimiter = ".";
+    // 	if (k.slice(0, 1) === delimiter) {
+    // 		return Error("[DexObj.getPath] path may not begin with a delimiter");
+    // 	}
+    // 	return this._getPath(k.split(delimiter));
+    // }
+    get(key) {
+        // if (this.reader) {
+        // 	this.reader.setAccessed();
+        // }
+        const entity = this.props.get(key);
+        if (entity instanceof DexRef) {
+            const value = entity.load(key);
+            this.props.set(key, value);
+            return value;
+        }
+        return entity;
+    }
+    loadAll(visited = []) {
+        if (visited.indexOf(this) !== -1) {
+            return;
+        }
+        visited.push(this);
+        for (const key of this.props.keys()) {
+            const entity = this.get(key);
+            if (entity instanceof Error) {
+                return entity;
+            }
+            else if (entity instanceof DexObj) {
+                entity.loadAll(visited);
+            }
+        }
+    }
+}