@configura/web-core 1.3.0-alpha.1 → 1.3.0-alpha.2

package/dist/cm/format/cmsym/components/instantiate.js

@@ -1,121 +1,121 @@
-import { SymBox } from "./SymBox.js";
-import { SymComponent } from "./SymComponent.js";
-import { SymConnector } from "./SymConnector.js";
-import { SymGFX } from "./SymGFX.js";
-import { SymGMaterial } from "./SymGMaterial.js";
-import { SymGMaterialSelector } from "./SymGMaterialSelector.js";
-import { SymLight } from "./SymLight.js";
-import { SymLines2D } from "./SymLines2D.js";
-import { SymLODGroup } from "./SymLODGroup.js";
-import { SymMeasure } from "./SymMeasure.js";
-import { SymMesh } from "./SymMesh.js";
-import { SymMeshLight } from "./SymMeshLight.js";
-import { SymParams } from "./SymParams.js";
-import { SymPlane } from "./SymPlane.js";
-import { SymPlaneDivider } from "./SymPlaneDivider.js";
-import { SymProgs } from "./SymProgs.js";
-import { SymProps } from "./SymProps.js";
-import { SymReps } from "./SymReps.js";
-import { SymShape } from "./SymShape.js";
-import { SymSphere } from "./SymSphere.js";
-import { SymSpotlight } from "./SymSpotlight.js";
-import { SymTags } from "./SymTags.js";
-import { SymText2D } from "./SymText2D.js";
-import { SymText3D } from "./SymText3D.js";
-import { SymTransform } from "./SymTransform.js";
-import { SymUVMapper } from "./SymUVMapper.js";
-export function instantiate(key) {
-    switch (key) {
-        case "symBox":
-        case "SymBox":
-            return new SymBox();
-        case "symSphere":
-        case "SymSphere":
-            return new SymSphere();
-        case "symConnector":
-        case "SymConnector":
-            return new SymConnector();
-        case "symGfx":
-        case "SymGfx":
-            return new SymGFX();
-        case "symGMaterial":
-        case "SymGMaterial":
-            return new SymGMaterial();
-        case "symGMaterialSelector":
-        case "SymGMaterialSelector":
-            return new SymGMaterialSelector();
-        case "symMesh":
-        case "SymMesh":
-            return new SymMesh();
-        case "symReps":
-        case "SymReps":
-            return new SymReps();
-        case "symProps":
-        case "SymProps":
-            return new SymProps();
-        case "symLines2D":
-        case "SymLines2D":
-            return new SymLines2D();
-        case "symText2D":
-        case "SymText2D":
-            return new SymText2D();
-        case "symText3D":
-        case "SymText3D":
-            return new SymText3D();
-        case "symLODGroup":
-        case "SymLODGroup":
-            return new SymLODGroup();
-        case "symShape":
-        case "SymShape":
-            return new SymShape();
-        case "SymTags":
-            return new SymTags();
-        case "symTransform":
-        case "SymTransform":
-            return new SymTransform();
-        case "symParams":
-        case "SymParams":
-            // TODO: replace with real implementation
-            return new SymParams();
-        case "symMeasure":
-        case "SymMeasure":
-            return new SymMeasure();
-        case "symProgs":
-        case "SymProgs":
-            // TODO: replace with real implementation
-            return new SymProgs();
-        case "symPlane":
-        case "SymPlane":
-            return new SymPlane();
-        case "symPlaneDivider":
-        case "SymPlaneDivider":
-            // TODO: replace with real implementation
-            return new SymPlaneDivider();
-        case "symUVMapper":
-        case "SymUVMapper":
-            return new SymUVMapper();
-        case "symPoints":
-        case "SymPoints":
-            // SymPoints isn't necessary for Web Configurator
-            return new SymComponent("symPoints");
-        case "flags":
-        case "Flags":
-            // TODO: replace with real implementation
-            return new SymComponent("flags");
-        case "symLight":
-        case "SymLight":
-            // TODO: replace with real implementation
-            return new SymLight();
-        case "symMeshLight":
-        case "SymMeshLight":
-            // TODO: replace with real implementation
-            return new SymMeshLight();
-        case "symSpotlight":
-        case "SymSpotlight":
-            // TODO: replace with real implementation
-            return new SymSpotlight();
-        default:
-            break;
-    }
-    throw Error("[instantiate] not implemented for " + key);
-}
+import { SymBox } from "./SymBox.js";
+import { SymComponent } from "./SymComponent.js";
+import { SymConnector } from "./SymConnector.js";
+import { SymGFX } from "./SymGFX.js";
+import { SymGMaterial } from "./SymGMaterial.js";
+import { SymGMaterialSelector } from "./SymGMaterialSelector.js";
+import { SymLight } from "./SymLight.js";
+import { SymLines2D } from "./SymLines2D.js";
+import { SymLODGroup } from "./SymLODGroup.js";
+import { SymMeasure } from "./SymMeasure.js";
+import { SymMesh } from "./SymMesh.js";
+import { SymMeshLight } from "./SymMeshLight.js";
+import { SymParams } from "./SymParams.js";
+import { SymPlane } from "./SymPlane.js";
+import { SymPlaneDivider } from "./SymPlaneDivider.js";
+import { SymProgs } from "./SymProgs.js";
+import { SymProps } from "./SymProps.js";
+import { SymReps } from "./SymReps.js";
+import { SymShape } from "./SymShape.js";
+import { SymSphere } from "./SymSphere.js";
+import { SymSpotlight } from "./SymSpotlight.js";
+import { SymTags } from "./SymTags.js";
+import { SymText2D } from "./SymText2D.js";
+import { SymText3D } from "./SymText3D.js";
+import { SymTransform } from "./SymTransform.js";
+import { SymUVMapper } from "./SymUVMapper.js";
+export function instantiate(key) {
+    switch (key) {
+        case "symBox":
+        case "SymBox":
+            return new SymBox();
+        case "symSphere":
+        case "SymSphere":
+            return new SymSphere();
+        case "symConnector":
+        case "SymConnector":
+            return new SymConnector();
+        case "symGfx":
+        case "SymGfx":
+            return new SymGFX();
+        case "symGMaterial":
+        case "SymGMaterial":
+            return new SymGMaterial();
+        case "symGMaterialSelector":
+        case "SymGMaterialSelector":
+            return new SymGMaterialSelector();
+        case "symMesh":
+        case "SymMesh":
+            return new SymMesh();
+        case "symReps":
+        case "SymReps":
+            return new SymReps();
+        case "symProps":
+        case "SymProps":
+            return new SymProps();
+        case "symLines2D":
+        case "SymLines2D":
+            return new SymLines2D();
+        case "symText2D":
+        case "SymText2D":
+            return new SymText2D();
+        case "symText3D":
+        case "SymText3D":
+            return new SymText3D();
+        case "symLODGroup":
+        case "SymLODGroup":
+            return new SymLODGroup();
+        case "symShape":
+        case "SymShape":
+            return new SymShape();
+        case "SymTags":
+            return new SymTags();
+        case "symTransform":
+        case "SymTransform":
+            return new SymTransform();
+        case "symParams":
+        case "SymParams":
+            // TODO: replace with real implementation
+            return new SymParams();
+        case "symMeasure":
+        case "SymMeasure":
+            return new SymMeasure();
+        case "symProgs":
+        case "SymProgs":
+            // TODO: replace with real implementation
+            return new SymProgs();
+        case "symPlane":
+        case "SymPlane":
+            return new SymPlane();
+        case "symPlaneDivider":
+        case "SymPlaneDivider":
+            // TODO: replace with real implementation
+            return new SymPlaneDivider();
+        case "symUVMapper":
+        case "SymUVMapper":
+            return new SymUVMapper();
+        case "symPoints":
+        case "SymPoints":
+            // SymPoints isn't necessary for Web Configurator
+            return new SymComponent("symPoints");
+        case "flags":
+        case "Flags":
+            // TODO: replace with real implementation
+            return new SymComponent("flags");
+        case "symLight":
+        case "SymLight":
+            // TODO: replace with real implementation
+            return new SymLight();
+        case "symMeshLight":
+        case "SymMeshLight":
+            // TODO: replace with real implementation
+            return new SymMeshLight();
+        case "symSpotlight":
+        case "SymSpotlight":
+            // TODO: replace with real implementation
+            return new SymSpotlight();
+        default:
+            break;
+    }
+    throw Error("[instantiate] not implemented for " + key);
+}

package/dist/cm/format/cmsym/components/legacy.d.ts

@@ -1,8 +1,8 @@
-import { Logger } from "@configura/web-utilities";
-import { DexObj } from "../../dex/DexObj.js";
-import { SymImportEnv } from "../SymImportEnv.js";
-import { SymNode } from "../SymNode.js";
-import { DexObjKey, SymComponentKey } from "./SymComponent.js";
-export declare function loadLegacyComponent(logger: Logger, node: SymNode, key: SymComponentKey | DexObjKey, obj: DexObj, env: SymImportEnv, force: boolean): boolean;
-export declare function loadSymCache(logger: Logger, node: SymNode, key: SymComponentKey | DexObjKey, obj: DexObj, env: SymImportEnv, force: boolean): void;
+import { Logger } from "@configura/web-utilities";
+import { DexObj } from "../../dex/DexObj.js";
+import { SymImportEnv } from "../SymImportEnv.js";
+import { SymNode } from "../SymNode.js";
+import { DexObjKey, SymComponentKey } from "./SymComponent.js";
+export declare function loadLegacyComponent(logger: Logger, node: SymNode, key: SymComponentKey | DexObjKey, obj: DexObj, env: SymImportEnv, force: boolean): boolean;
+export declare function loadSymCache(logger: Logger, node: SymNode, key: SymComponentKey | DexObjKey, obj: DexObj, env: SymImportEnv, force: boolean): void;
 //# sourceMappingURL=legacy.d.ts.map

package/dist/cm/format/cmsym/components/legacy.js

@@ -1,27 +1,27 @@
-import { Semver } from "../../../io/Semver.js";
-import { SymProps } from "./SymProps.js";
-export function loadLegacyComponent(logger, node, key, obj, env, force) {
-    if (obj.type === "SymText" && env.fileVersion.lte(new Semver(1, 1, 0))) {
-        throw logger.errorAsObject("[loadLegacyComponent] loadSymText(z, key, dex);");
-    }
-    if (obj.type === "SymPoint" && env.fileVersion.lte(new Semver(1, 2, 0))) {
-        throw logger.errorAsObject("[loadLegacyComponent] loadSymPoint(z, key, dex);");
-    }
-    if (obj.type === "SymLine" && env.fileVersion.lte(new Semver(1, 2, 0))) {
-        throw logger.errorAsObject("[loadLegacyComponent] loadSymLine(z, key, dex);");
-    }
-    if (obj.type === "SymCache" && env.fileVersion.lte(new Semver(1, 2, 1))) {
-        loadSymCache(logger, node, key, obj, env, force);
-        return true;
-    }
-    if (obj.type === "SymLines" && env.fileVersion.lte(new Semver(1, 2, 2))) {
-        throw logger.errorAsObject("[loadLegacyComponent] loadSymLines(z, key, dex, env, force);");
-    }
-    return false;
-}
-export function loadSymCache(logger, node, key, obj, env, force) {
-    const props = new SymProps();
-    props.load(logger, obj, env, force);
-    node.addComponent(props, false);
-    node.components.delete(key);
-}
+import { Semver } from "../../../io/Semver.js";
+import { SymProps } from "./SymProps.js";
+export function loadLegacyComponent(logger, node, key, obj, env, force) {
+    if (obj.type === "SymText" && env.fileVersion.lte(new Semver(1, 1, 0))) {
+        throw logger.errorAsObject("[loadLegacyComponent] loadSymText(z, key, dex);");
+    }
+    if (obj.type === "SymPoint" && env.fileVersion.lte(new Semver(1, 2, 0))) {
+        throw logger.errorAsObject("[loadLegacyComponent] loadSymPoint(z, key, dex);");
+    }
+    if (obj.type === "SymLine" && env.fileVersion.lte(new Semver(1, 2, 0))) {
+        throw logger.errorAsObject("[loadLegacyComponent] loadSymLine(z, key, dex);");
+    }
+    if (obj.type === "SymCache" && env.fileVersion.lte(new Semver(1, 2, 1))) {
+        loadSymCache(logger, node, key, obj, env, force);
+        return true;
+    }
+    if (obj.type === "SymLines" && env.fileVersion.lte(new Semver(1, 2, 2))) {
+        throw logger.errorAsObject("[loadLegacyComponent] loadSymLines(z, key, dex, env, force);");
+    }
+    return false;
+}
+export function loadSymCache(logger, node, key, obj, env, force) {
+    const props = new SymProps();
+    props.load(logger, obj, env, force);
+    node.addComponent(props, false);
+    node.components.delete(key);
+}

package/dist/cm/format/cmsym/components/mesh.d.ts

@@ -1,9 +1,9 @@
-import { Logger } from "@configura/web-utilities";
-import { DetailLevel } from "../../../geometry/DetailMask.js";
-import { SymNode } from "../SymNode.js";
-export interface TaggedNode {
-    node: SymNode;
-    tags: string[];
-}
-export declare function findMeshNodes(logger: Logger, node: SymNode, detail: DetailLevel, tags: string[], meshNodes: TaggedNode[]): TaggedNode[];
+import { Logger } from "@configura/web-utilities";
+import { DetailLevel } from "../../../geometry/DetailMask.js";
+import { SymNode } from "../SymNode.js";
+export interface TaggedNode {
+    node: SymNode;
+    tags: string[];
+}
+export declare function findMeshNodes(logger: Logger, node: SymNode, detail: DetailLevel, tags: string[], meshNodes: TaggedNode[]): TaggedNode[];
 //# sourceMappingURL=mesh.d.ts.map

package/dist/cm/format/cmsym/components/mesh.js

@@ -1,28 +1,28 @@
-import { SymGfxMode } from "./SymComponent.js";
-export function findMeshNodes(logger, node, detail, tags, meshNodes) {
-    const symTags = node.symTags();
-    if (symTags !== undefined && symTags.main !== undefined) {
-        tags = tags.slice();
-        tags.push(symTags.main);
-    }
-    const symMesh = node.symMesh();
-    if (symMesh !== undefined) {
-        const symReps = node.symReps();
-        if (symReps !== undefined && symReps._details !== undefined) {
-            const lod = symReps._details.get(SymGfxMode.x3D);
-            if (lod !== undefined && lod.includes(detail)) {
-                meshNodes.push({ node, tags });
-            }
-        }
-        else {
-            meshNodes.push({ node, tags });
-        }
-    }
-    const children = node.children(logger, false, true);
-    if (children && children.size > 0) {
-        for (const child of children.values()) {
-            meshNodes = findMeshNodes(logger, child, detail, tags, meshNodes);
-        }
-    }
-    return meshNodes;
-}
+import { SymGfxMode } from "./SymComponent.js";
+export function findMeshNodes(logger, node, detail, tags, meshNodes) {
+    const symTags = node.symTags();
+    if (symTags !== undefined && symTags.main !== undefined) {
+        tags = tags.slice();
+        tags.push(symTags.main);
+    }
+    const symMesh = node.symMesh();
+    if (symMesh !== undefined) {
+        const symReps = node.symReps();
+        if (symReps !== undefined && symReps._details !== undefined) {
+            const lod = symReps._details.get(SymGfxMode.x3D);
+            if (lod !== undefined && lod.includes(detail)) {
+                meshNodes.push({ node, tags });
+            }
+        }
+        else {
+            meshNodes.push({ node, tags });
+        }
+    }
+    const children = node.children(logger, false, true);
+    if (children && children.size > 0) {
+        for (const child of children.values()) {
+            meshNodes = findMeshNodes(logger, child, detail, tags, meshNodes);
+        }
+    }
+    return meshNodes;
+}

package/dist/cm/format/cmsym/invalidation.d.ts

@@ -1,5 +1,5 @@
-import { SymInv } from "./SymInv.js";
-import { SymNode } from "./SymNode.js";
-export declare function appendInvalidation(invalidation: SymInv[], node: SymNode, removed: boolean): void;
-export declare function invalidate(node: SymNode, invalidation: SymInv[], xtrace?: boolean): void;
+import { SymInv } from "./SymInv.js";
+import { SymNode } from "./SymNode.js";
+export declare function appendInvalidation(invalidation: SymInv[], node: SymNode, removed: boolean): void;
+export declare function invalidate(node: SymNode, invalidation: SymInv[], xtrace?: boolean): void;
 //# sourceMappingURL=invalidation.d.ts.map

package/dist/cm/format/cmsym/invalidation.js

@@ -1,72 +1,72 @@
-import { InvalidationEnv } from "./InvalidationEnv.js";
-export function appendInvalidation(invalidation, node, removed) {
-    for (const component of node.components.values()) {
-        const inv = component.invalidation(removed);
-        if (inv !== undefined) {
-            invalidation.push(...inv);
-        }
-    }
-    // if (node.userCached && !node.symUCache) {
-    // 	invalidation.push(SymUCacheInv(node, removed));
-    // }
-}
-export function invalidate(node, invalidation, xtrace = false) {
-    if (invalidation.length === 0) {
-        return;
-    }
-    if (xtrace) {
-        console.log(`invalidate(${node.id},${invalidation.length})`);
-    }
-    const stack = [new InvalidationEnv(node, invalidation)];
-    while (stack.length > 0) {
-        const env = stack.pop();
-        if (env === undefined) {
-            continue;
-        }
-        if (xtrace) {
-            env.dump();
-        }
-        const keep = [];
-        for (const inv of env.invalidation) {
-            if (inv.skip(env.node)) {
-                if (xtrace) {
-                    console.log(`${" ".repeat(env.n + 1)}skip origin, ${env.node} ${inv}`);
-                }
-                keep.push(inv);
-            }
-            else if (inv.needToInvalidate(env.node)) {
-                if (xtrace) {
-                    console.log(`${" ".repeat(env.n + 1)}invalidate, ${env.node} ${inv}`);
-                }
-                inv.invalidate(env.node);
-                if (inv.propagate()) {
-                    keep.push(inv);
-                }
-            }
-            else {
-                if (xtrace) {
-                    console.log(`${" ".repeat(env.n + 1)}skip, ${env.node} ${inv}`);
-                }
-            }
-        }
-        const parents = env.node._parents;
-        if (keep.length > 0 && parents && parents.length > 0) {
-            if (xtrace) {
-                console.log(`${" ".repeat(env.n + 1)}keep, ${keep.length}`);
-            }
-            for (let i = 0; i < parents.length; i++) {
-                const parent = parents[i];
-                const inv = i > 0 ? keep.slice() : keep;
-                stack.push(new InvalidationEnv(parent, inv, env.n + 2));
-            }
-        }
-        else {
-            if (xtrace && keep.length === 0) {
-                console.log(`${" ".repeat(env.n + 1)}keep empty`);
-            }
-            if (xtrace && (parents === undefined || parents.length === 0)) {
-                console.log(`${" ".repeat(env.n + 1)}parents empty`);
-            }
-        }
-    }
-}
+import { InvalidationEnv } from "./InvalidationEnv.js";
+export function appendInvalidation(invalidation, node, removed) {
+    for (const component of node.components.values()) {
+        const inv = component.invalidation(removed);
+        if (inv !== undefined) {
+            invalidation.push(...inv);
+        }
+    }
+    // if (node.userCached && !node.symUCache) {
+    // 	invalidation.push(SymUCacheInv(node, removed));
+    // }
+}
+export function invalidate(node, invalidation, xtrace = false) {
+    if (invalidation.length === 0) {
+        return;
+    }
+    if (xtrace) {
+        console.log(`invalidate(${node.id},${invalidation.length})`);
+    }
+    const stack = [new InvalidationEnv(node, invalidation)];
+    while (stack.length > 0) {
+        const env = stack.pop();
+        if (env === undefined) {
+            continue;
+        }
+        if (xtrace) {
+            env.dump();
+        }
+        const keep = [];
+        for (const inv of env.invalidation) {
+            if (inv.skip(env.node)) {
+                if (xtrace) {
+                    console.log(`${" ".repeat(env.n + 1)}skip origin, ${env.node} ${inv}`);
+                }
+                keep.push(inv);
+            }
+            else if (inv.needToInvalidate(env.node)) {
+                if (xtrace) {
+                    console.log(`${" ".repeat(env.n + 1)}invalidate, ${env.node} ${inv}`);
+                }
+                inv.invalidate(env.node);
+                if (inv.propagate()) {
+                    keep.push(inv);
+                }
+            }
+            else {
+                if (xtrace) {
+                    console.log(`${" ".repeat(env.n + 1)}skip, ${env.node} ${inv}`);
+                }
+            }
+        }
+        const parents = env.node._parents;
+        if (keep.length > 0 && parents && parents.length > 0) {
+            if (xtrace) {
+                console.log(`${" ".repeat(env.n + 1)}keep, ${keep.length}`);
+            }
+            for (let i = 0; i < parents.length; i++) {
+                const parent = parents[i];
+                const inv = i > 0 ? keep.slice() : keep;
+                stack.push(new InvalidationEnv(parent, inv, env.n + 2));
+            }
+        }
+        else {
+            if (xtrace && keep.length === 0) {
+                console.log(`${" ".repeat(env.n + 1)}keep empty`);
+            }
+            if (xtrace && (parents === undefined || parents.length === 0)) {
+                console.log(`${" ".repeat(env.n + 1)}parents empty`);
+            }
+        }
+    }
+}

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

@@ -1,10 +1,10 @@
-import { DexReader, DexSerializable } from "./DexReader.js";
-import { DexRef } from "./DexRef.js";
-export declare class DexIRef extends DexRef {
-    reader: DexReader;
-    pos: number;
-    constructor(reader: DexReader, pos: number);
-    load(key?: string): DexSerializable;
-    toString(): string;
-}
+import { DexReader, DexSerializable } from "./DexReader.js";
+import { DexRef } from "./DexRef.js";
+export declare class DexIRef extends DexRef {
+    reader: DexReader;
+    pos: number;
+    constructor(reader: DexReader, pos: number);
+    load(key?: string): DexSerializable;
+    toString(): string;
+}
 //# sourceMappingURL=DexIRef.d.ts.map

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

@@ -1,18 +1,18 @@
-import { DexRef } from "./DexRef.js";
-export class DexIRef extends DexRef {
-    constructor(reader, pos) {
-        super(reader);
-        this.reader = reader;
-        this.pos = pos;
-    }
-    load(key) {
-        const obj = this.reader.readObjectFromPos(this.pos);
-        if (obj instanceof DexRef) {
-            return obj.load(key);
-        }
-        return obj;
-    }
-    toString() {
-        return `DexIRef(${this.reader},${this.pos})`;
-    }
-}
+import { DexRef } from "./DexRef.js";
+export class DexIRef extends DexRef {
+    constructor(reader, pos) {
+        super(reader);
+        this.reader = reader;
+        this.pos = pos;
+    }
+    load(key) {
+        const obj = this.reader.readObjectFromPos(this.pos);
+        if (obj instanceof DexRef) {
+            return obj.load(key);
+        }
+        return obj;
+    }
+    toString() {
+        return `DexIRef(${this.reader},${this.pos})`;
+    }
+}

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

@@ -1,12 +1,12 @@
-export declare class DexInt {
-    value: number;
-    constructor(value: number);
-    toString(): string;
-}
-export declare class DexInt64 {
-    private high;
-    private low;
-    constructor(high: number, low: number);
-    toString(): string;
-}
+export declare class DexInt {
+    value: number;
+    constructor(value: number);
+    toString(): string;
+}
+export declare class DexInt64 {
+    private high;
+    private low;
+    constructor(high: number, low: number);
+    toString(): string;
+}
 //# sourceMappingURL=DexInt.d.ts.map