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

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

@@ -1,652 +1,652 @@
-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 { v4 } from "uuid";
-import { Semver } from "../../io/Semver.js";
-import { DexObj } from "../dex/DexObj.js";
-import { DexVersion } from "../dex/DexVersion.js";
-import { instantiate } from "./components/instantiate.js";
-import { loadLegacyComponent } from "./components/legacy.js";
-import { findMeshNodes } from "./components/mesh.js";
-import { SymBox } from "./components/SymBox.js";
-import { SymComponent } from "./components/SymComponent.js";
-import { SymDexObj } from "./components/SymDexObj.js";
-import { SymGMaterial } from "./components/SymGMaterial.js";
-import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
-import { SymMeasure } from "./components/SymMeasure.js";
-import { SymMesh } from "./components/SymMesh.js";
-import { SymPlane } from "./components/SymPlane.js";
-import { SymProps, SYM_FEATURES_KEY, SYM_GEOMETRY_KEY, SYM_LOCAL_BOUND_KEY, SYM_NODE_KEY, SYM_STRUCTURAL_KEY, } from "./components/SymProps.js";
-import { SymReps } from "./components/SymReps.js";
-import { SymSphere } from "./components/SymSphere.js";
-import { SymTags } from "./components/SymTags.js";
-import { SymTransform } from "./components/SymTransform.js";
-import { SymUVMapper } from "./components/SymUVMapper.js";
-import { appendInvalidation, invalidate } from "./invalidation.js";
-import { SymImportEnv } from "./SymImportEnv.js";
-export const VERBOSE_SYM_LOGGING = false;
-export class SymNode {
-    constructor(id) {
-        this.id = id;
-        this.components = new Map();
-        this._isStretch = new Map();
-        if (VERBOSE_SYM_LOGGING) {
-            console.log("SymNode: " + id);
-        }
-    }
-    setId(logger, newId) {
-        if (this.id === newId) {
-            return;
-        }
-        if (this._parents !== undefined) {
-            for (const parent of this._parents) {
-                const children = parent.children(logger, true, true);
-                if (children.has(newId)) {
-                    throw logger.errorAsObject("cannot have children with the same id, for any parent");
-                }
-            }
-            for (const parent of this._parents) {
-                parent.breakDexConnection();
-                // children already loaded for all parents
-                const children = parent.children(logger, true, false);
-                if (children.size === 0) {
-                    continue;
-                }
-                children.delete(this.id);
-                children.set(newId, this);
-            }
-        }
-        this.id = newId;
-    }
-    children(logger, safe = false, load = true) {
-        if (load) {
-            this.ensureChildrenLoaded(logger);
-        }
-        if (this._children === undefined && safe) {
-            this._children = new Map();
-        }
-        return this._children;
-    }
-    ensureChildrenLoaded(logger) {
-        const component = this.childrenProvider();
-        if (component instanceof SymComponent) {
-            component.loadChildren();
-        }
-        else if (this.dexObj() !== undefined &&
-            (this._children === undefined || this._children.size < this.dexChildrenCount())) {
-            this.loadDexChildren(logger);
-        }
-    }
-    dexChildrenCount() {
-        const obj = this.dexObj();
-        if (obj === undefined) {
-            return 0;
-        }
-        const dexChildren = obj.get("children");
-        if (dexChildren instanceof DexObj && dexChildren.props !== undefined) {
-            return dexChildren.props.size;
-        }
-        return 0;
-    }
-    loadDexChildren(logger) {
-        const obj = this.dexObj();
-        if (obj === undefined) {
-            throw logger.errorAsObject("this.dexObj() is undefined");
-        }
-        if (this.featureProvider("children") !== undefined) {
-            throw logger.errorAsObject("this.featureProvider('children') must be undefined");
-        }
-        const dexChildren = obj.get("children");
-        if (dexChildren instanceof DexObj && dexChildren.props !== undefined) {
-            const env = this.importEnv();
-            if (env === undefined) {
-                throw logger.errorAsObject("env must not be undefined");
-            }
-            for (const key of dexChildren.props.keys()) {
-                this.loadChild(logger, dexChildren, key, env);
-            }
-        }
-    }
-    addChild(logger, child, invalidate = true) {
-        if (child === this) {
-            throw logger.errorAsObject("Trying to add node as a child of itself.");
-        }
-        if (invalidate && this.hasComponent("xRef")) {
-            throw logger.errorAsObject("Trying to add a child to an xRef node");
-        }
-        if (invalidate) {
-            this.breakDexConnection();
-        }
-        const children = this.children(logger, true, invalidate);
-        if (children.has(child.id)) {
-            child.setId(logger, v4());
-        }
-        children.set(child.id, child);
-        child.addParent(this, false);
-        if (invalidate) {
-            child.invalidateParent(this, false);
-        }
-        return;
-    }
-    loadChild(logger, dexChildren, id, env) {
-        if (this._children !== undefined) {
-            const child = this._children.get(id);
-            if (child !== undefined) {
-                return child;
-            }
-        }
-        const dexChild = dexChildren.get(id);
-        if (dexChild instanceof DexObj) {
-            if (this._children === undefined) {
-                this._children = new Map();
-            }
-            const child = toSymNode(logger, dexChild, this, env, false);
-            return child;
-        }
-    }
-    // Parent
-    addParent(parent, safe = true) {
-        if (parent !== undefined) {
-            if (this._parents === undefined) {
-                this._parents = [];
-            }
-            if (safe && this._parents.indexOf(parent) === -1) {
-                return;
-            }
-            this._parents.push(parent);
-        }
-    }
-    invalidateParent(parent, removed) {
-        const invalidation = [];
-        appendInvalidation(invalidation, this, removed);
-        invalidate(parent, invalidation, true);
-    }
-    invalidate(removed) {
-        const invalidation = [];
-        appendInvalidation(invalidation, this, removed);
-        invalidate(this, invalidation, true);
-    }
-    // Env
-    importEnv(ascend = true) {
-        const obj = this.symDexObj();
-        if (obj instanceof SymDexObj) {
-            return obj.importEnv;
-        }
-        if (!ascend || this._parents === undefined || this._parents.length === 0) {
-            return;
-        }
-        const env = this._parents[0].importEnv(ascend);
-        if (env instanceof SymImportEnv) {
-            this.setImportEnv(env);
-        }
-        return env;
-    }
-    setImportEnv(env) {
-        const obj = this.symDexObj();
-        if (obj instanceof Error) {
-            return obj;
-        }
-        else if (obj instanceof SymDexObj) {
-            obj.importEnv = env;
-        }
-    }
-    // Props
-    set(key, value) {
-        return this.symProps(true).set(key, value);
-    }
-    get(key) {
-        return this.symProps(true).get(key);
-    }
-    has(key) {
-        return this.symProps(true).has(key);
-    }
-    fillPropsAfterLoad() {
-        const symProps = this.symProps(false);
-        if (symProps instanceof Error || symProps === undefined) {
-            return symProps;
-        }
-        const requiredKeys = [
-            SYM_GEOMETRY_KEY,
-            SYM_STRUCTURAL_KEY,
-            SYM_NODE_KEY,
-            SYM_LOCAL_BOUND_KEY,
-        ];
-        for (const key of requiredKeys) {
-            if (!symProps.has(key)) {
-                symProps.set(key, undefined);
-            }
-        }
-    }
-    hasDexComponent(key) {
-        const obj = this.dexObj();
-        if (obj instanceof Error) {
-            return obj;
-        }
-        else if (obj === undefined) {
-            return false;
-        }
-        return obj.has(key);
-    }
-    breakDexConnection(loadChildren = true, descend = true) {
-        const obj = this.dexObj();
-        if (obj === undefined) {
-            return;
-        }
-        const env = this.importEnv();
-        if (env === undefined) {
-            throw Error("[breakDexConnection] could not get env!");
-        }
-        this._breakDexConnection(env, loadChildren, descend);
-    }
-    _breakDexConnection(env, loadChildren, descend) {
-        // console.warn(`SymNode._breakDexConnection ${env} ${descend}`);
-    }
-    dexObj() {
-        const obj = this.symDexObj();
-        return obj && obj.dexObj;
-    }
-    symDexObj() {
-        const component = this.getComponent("symDexObj");
-        if (component instanceof SymDexObj) {
-            return component;
-        }
-    }
-    symGMaterial(safe) {
-        const component = this.getComponent("symGMaterial");
-        if (component instanceof SymGMaterial) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymGMaterial();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symGMaterialSelector(safe) {
-        const component = this.getComponent("symGMaterialSelector");
-        if (component instanceof SymGMaterialSelector) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymGMaterialSelector();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symMesh(safe) {
-        const component = this.getComponent("symMesh");
-        if (component instanceof SymMesh) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymMesh();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symSphere(safe) {
-        const component = this.getComponent("symSphere");
-        if (component instanceof SymSphere) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymSphere();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symBox(safe) {
-        const component = this.getComponent("symBox");
-        if (component instanceof SymBox) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymBox();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symPlane(safe) {
-        const component = this.getComponent("symPlane");
-        if (component instanceof SymPlane) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymPlane();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symProps(safe) {
-        const component = this.getComponent("symProps");
-        if (component instanceof SymProps) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymProps();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symReps(safe) {
-        const component = this.getComponent("symReps");
-        if (component instanceof SymReps) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymReps();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symTags(safe) {
-        const component = this.getComponent("symTags");
-        if (component instanceof SymTags) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymTags();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symTransform(safe) {
-        const component = this.getComponent("symTransform");
-        if (component instanceof SymTransform) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymTransform();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    symUVMapper(safe) {
-        const component = this.getComponent("symUVMapper");
-        if (component instanceof SymUVMapper) {
-            return component;
-        }
-        else if (safe) {
-            const component = new SymUVMapper();
-            this.addComponent(component);
-            return component;
-        }
-    }
-    getMeasure() {
-        const component = this.components.get("symMeasure");
-        if (component instanceof SymMeasure) {
-            return component;
-        }
-    }
-    isStretch(logger, detailLevel) {
-        let isStretch = this._isStretch.get(detailLevel);
-        if (isStretch === undefined) {
-            isStretch = symNodeIsStretch(logger, this, detailLevel);
-            this._isStretch.set(detailLevel, isStretch);
-        }
-        return isStretch;
-    }
-    // Components
-    getComponent(key) {
-        return this.components.get(key);
-    }
-    addComponent(component, invalidate = true) {
-        if (invalidate && component.breaksDex() && this.hasDexComponent(component.id)) {
-            this.breakDexConnection(false);
-        }
-        if (component.node && component.node !== this) {
-            throw Error("[SymNode.addComponent] component already has node.");
-            // component = component.copy();
-        }
-        if (this._children !== undefined) {
-            const features = component.features();
-            if (features !== undefined && features.has("children")) {
-                throw Error("[SymNode.addComponent] node already has children");
-            }
-        }
-        component.addComponent(this, invalidate);
-        this.components.set(component.id, component);
-        component.componentAdded(invalidate);
-    }
-    hasComponent(key) {
-        return this.components.has(key);
-    }
-    removeComponent(key, invalidate = true) {
-        throw Error(`SymNode.removeComponent ${key} ${invalidate}`);
-    }
-    loadComponents(logger, force = false) {
-        const obj = this.dexObj();
-        if (obj === undefined || obj.props === undefined) {
-            return;
-        }
-        const env = this.importEnv();
-        let breakDex = false;
-        for (const key of obj.props.keys()) {
-            const prop = obj.get(key);
-            if (prop instanceof DexObj) {
-                const breaks = this.loadComponent(logger, key, prop, env, force);
-                if (breaks) {
-                    breakDex = true;
-                }
-            }
-        }
-        this.prepareAfterLoad();
-        if (breakDex) {
-            this.breakDexConnection();
-        }
-    }
-    loadComponent(logger, key, obj, env, force = false) {
-        if (env === undefined) {
-            env = this.importEnv();
-        }
-        if (env === undefined) {
-            throw logger.errorAsObject("[loadComponentObj] could not get env!");
-        }
-        else if (key === "children") {
-            return false;
-        }
-        else if (loadLegacyComponent(logger, this, key, obj, env, force)) {
-            return true;
-        }
-        const type = obj.type;
-        if (type === undefined) {
-            throw logger.errorAsObject("[loadComponentObj] obj has no type!");
-        }
-        const component = instantiate(type);
-        if (component instanceof SymComponent) {
-            this.addComponent(component, false);
-            component.load(logger, obj, env, force);
-        }
-        return false;
-    }
-    prepareAfterLoad() {
-        this.buildFeatures();
-        this.fillPropsAfterLoad();
-    }
-    features(create = false) {
-        const features = this.get(SYM_FEATURES_KEY);
-        if (features instanceof Map) {
-            return features;
-        }
-        else if (create) {
-            const features = new Map();
-            this.set(SYM_FEATURES_KEY, features);
-            return features;
-        }
-        throw Error("no features");
-    }
-    featureProviderKey(feature) {
-        return this.features().get(feature);
-    }
-    featureProvider(feature) {
-        const key = this.featureProviderKey(feature);
-        if (key === undefined) {
-            return;
-        }
-        return this.getComponent(key);
-    }
-    buildFeatures() {
-        const features = new Map();
-        for (const component of this.components.values()) {
-            const cFeatures = component.features();
-            if (cFeatures === undefined) {
-                continue;
-            }
-            for (const feature of cFeatures) {
-                features.set(feature, component.id);
-            }
-        }
-        this.set(SYM_FEATURES_KEY, features);
-        return features;
-    }
-    addFeaturesFrom(component) {
-        const features = component.features();
-        if (features === undefined || features.size === 0) {
-            return;
-        }
-        const nodeFeatures = this.features(true);
-        for (const feature of features) {
-            const key = this.featureProviderKey(feature);
-            if (key !== undefined) {
-                this.removeComponent(key, false);
-            }
-            nodeFeatures.set(feature, component.id);
-        }
-        if (features.has("mesh")) {
-            console.warn("mesh cache should be invalidated!" + component);
-        }
-    }
-    childrenProvider() {
-        return this.featureProvider("children");
-    }
-    meshProvider() {
-        return this.featureProvider("mesh");
-    }
-    get3DTmp(logger, detail) {
-        return findMeshNodes(logger, this, detail, [], []);
-    }
-    toString() {
-        return `SymNode("${this.id}")`;
-    }
-}
-export function toSymNode(logger, obj, parent, env, putImportEnv = false) {
-    if (env !== undefined) {
-        const node = env.sharedNodeMap.get(obj);
-        if (node instanceof SymNode) {
-            if (parent) {
-                parent.addChild(logger, node, false);
-            }
-            return node;
-        }
-    }
-    switch (obj.type) {
-        case "node":
-            return toSymBasicNode(logger, obj, parent, env, putImportEnv);
-        case "xRefNode":
-            return toSymXRefNode(obj, parent, env, putImportEnv);
-        case "symFile":
-            return toSymFileRoot(logger, obj, parent);
-    }
-    throw logger.errorAsObject("[toSymNode] Unknown obj.type:", obj.type);
-}
-function toSymBasicNode(logger, obj, parent, env, putImportEnv = false) {
-    if (env === undefined) {
-        throw logger.errorAsObject("[toSymBasicNode] no env");
-    }
-    if (obj.id === undefined) {
-        throw logger.errorAsObject("[toSymBasicNode] obj.id is undefined");
-    }
-    const node = new SymNode(obj.id);
-    node.addComponent(new SymDexObj(obj, env.fileVersion, env), false);
-    env.sharedNodeMap.set(obj, node);
-    if (parent !== undefined) {
-        parent.addChild(logger, node, false);
-    }
-    node.loadComponents(logger);
-    return node;
-}
-function toSymXRefNode(_obj, _parent, _env, _putImportEnv = false) {
-    throw Error("[toSymXRefNode]");
-}
-function toSymFileRoot(logger, obj, parent) {
-    const version = obj.get("version");
-    const semver = loadVersion(version);
-    // Enable to get CmSym version statistics in the Exerciser
-    // logger.info("CmSym version " + semver.toDisplayString());
-    const env = new SymImportEnv(semver);
-    const sym = obj.get("sym");
-    if (!(sym instanceof DexObj)) {
-        throw Error(`sym: ${sym} is not a DexObj`);
-    }
-    return toSymNode(logger, sym, parent, env, true);
-}
-function loadVersion(obj) {
-    if (obj instanceof DexObj) {
-        return Semver.fromDex(obj);
-    }
-    if (obj instanceof DexVersion) {
-        return obj.toSemver();
-    }
-    throw Error(`obj: ${obj} can't load version`);
-}
-export function loadSymFile(logger, url, manager, abortSignal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const root = yield manager.load(logger, url, abortSignal);
-        return makeSymFromDex(logger, root);
-    });
-}
-export function makeSymFromDex(logger, root) {
-    const node = toSymNode(logger, root);
-    if (!(node instanceof SymNode)) {
-        throw Error(`node: ${node} is not a SymNode`);
-    }
-    node.ensureChildrenLoaded(logger);
-    return node;
-}
-function symNodeIsStretch(logger, symNode, detailLevel) {
-    const symMeasure = symNode.getMeasure();
-    if (symMeasure === undefined) {
-        return false;
-    }
-    const children = symNode.children(logger, true, true);
-    let nodeName;
-    for (const [name, node] of children) {
-        if (name.startsWith("3D") || name.startsWith("2D")) {
-            const symReps = node.symReps(true);
-            const details = symReps._details;
-            if (details === undefined) {
-                continue;
-            }
-            const detailMask = details.values().next().value;
-            if (detailMask.includes(detailLevel)) {
-                nodeName = name;
-                break;
-            }
-        }
-    }
-    if (nodeName === undefined) {
-        logger.warn(`No 3D/2D SymNode which covers the detailLevel ${detailLevel} found`);
-        return false;
-    }
-    const node = children.get(nodeName);
-    if (node === undefined) {
-        return false;
-    }
-    const progsNode = node.components.get("symProgs");
-    if (progsNode === undefined) {
-        return false;
-    }
-    const symProgs = progsNode;
-    for (const prog of symProgs.progs) {
-        if (prog.isStretch) {
-            return true;
-        }
-    }
-    return false;
-}
+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 { v4 } from "uuid";
+import { Semver } from "../../io/Semver.js";
+import { DexObj } from "../dex/DexObj.js";
+import { DexVersion } from "../dex/DexVersion.js";
+import { instantiate } from "./components/instantiate.js";
+import { loadLegacyComponent } from "./components/legacy.js";
+import { findMeshNodes } from "./components/mesh.js";
+import { SymBox } from "./components/SymBox.js";
+import { SymComponent } from "./components/SymComponent.js";
+import { SymDexObj } from "./components/SymDexObj.js";
+import { SymGMaterial } from "./components/SymGMaterial.js";
+import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
+import { SymMeasure } from "./components/SymMeasure.js";
+import { SymMesh } from "./components/SymMesh.js";
+import { SymPlane } from "./components/SymPlane.js";
+import { SymProps, SYM_FEATURES_KEY, SYM_GEOMETRY_KEY, SYM_LOCAL_BOUND_KEY, SYM_NODE_KEY, SYM_STRUCTURAL_KEY, } from "./components/SymProps.js";
+import { SymReps } from "./components/SymReps.js";
+import { SymSphere } from "./components/SymSphere.js";
+import { SymTags } from "./components/SymTags.js";
+import { SymTransform } from "./components/SymTransform.js";
+import { SymUVMapper } from "./components/SymUVMapper.js";
+import { appendInvalidation, invalidate } from "./invalidation.js";
+import { SymImportEnv } from "./SymImportEnv.js";
+export const VERBOSE_SYM_LOGGING = false;
+export class SymNode {
+    constructor(id) {
+        this.id = id;
+        this.components = new Map();
+        this._isStretch = new Map();
+        if (VERBOSE_SYM_LOGGING) {
+            console.log("SymNode: " + id);
+        }
+    }
+    setId(logger, newId) {
+        if (this.id === newId) {
+            return;
+        }
+        if (this._parents !== undefined) {
+            for (const parent of this._parents) {
+                const children = parent.children(logger, true, true);
+                if (children.has(newId)) {
+                    throw logger.errorAsObject("cannot have children with the same id, for any parent");
+                }
+            }
+            for (const parent of this._parents) {
+                parent.breakDexConnection();
+                // children already loaded for all parents
+                const children = parent.children(logger, true, false);
+                if (children.size === 0) {
+                    continue;
+                }
+                children.delete(this.id);
+                children.set(newId, this);
+            }
+        }
+        this.id = newId;
+    }
+    children(logger, safe = false, load = true) {
+        if (load) {
+            this.ensureChildrenLoaded(logger);
+        }
+        if (this._children === undefined && safe) {
+            this._children = new Map();
+        }
+        return this._children;
+    }
+    ensureChildrenLoaded(logger) {
+        const component = this.childrenProvider();
+        if (component instanceof SymComponent) {
+            component.loadChildren();
+        }
+        else if (this.dexObj() !== undefined &&
+            (this._children === undefined || this._children.size < this.dexChildrenCount())) {
+            this.loadDexChildren(logger);
+        }
+    }
+    dexChildrenCount() {
+        const obj = this.dexObj();
+        if (obj === undefined) {
+            return 0;
+        }
+        const dexChildren = obj.get("children");
+        if (dexChildren instanceof DexObj && dexChildren.props !== undefined) {
+            return dexChildren.props.size;
+        }
+        return 0;
+    }
+    loadDexChildren(logger) {
+        const obj = this.dexObj();
+        if (obj === undefined) {
+            throw logger.errorAsObject("this.dexObj() is undefined");
+        }
+        if (this.featureProvider("children") !== undefined) {
+            throw logger.errorAsObject("this.featureProvider('children') must be undefined");
+        }
+        const dexChildren = obj.get("children");
+        if (dexChildren instanceof DexObj && dexChildren.props !== undefined) {
+            const env = this.importEnv();
+            if (env === undefined) {
+                throw logger.errorAsObject("env must not be undefined");
+            }
+            for (const key of dexChildren.props.keys()) {
+                this.loadChild(logger, dexChildren, key, env);
+            }
+        }
+    }
+    addChild(logger, child, invalidate = true) {
+        if (child === this) {
+            throw logger.errorAsObject("Trying to add node as a child of itself.");
+        }
+        if (invalidate && this.hasComponent("xRef")) {
+            throw logger.errorAsObject("Trying to add a child to an xRef node");
+        }
+        if (invalidate) {
+            this.breakDexConnection();
+        }
+        const children = this.children(logger, true, invalidate);
+        if (children.has(child.id)) {
+            child.setId(logger, v4());
+        }
+        children.set(child.id, child);
+        child.addParent(this, false);
+        if (invalidate) {
+            child.invalidateParent(this, false);
+        }
+        return;
+    }
+    loadChild(logger, dexChildren, id, env) {
+        if (this._children !== undefined) {
+            const child = this._children.get(id);
+            if (child !== undefined) {
+                return child;
+            }
+        }
+        const dexChild = dexChildren.get(id);
+        if (dexChild instanceof DexObj) {
+            if (this._children === undefined) {
+                this._children = new Map();
+            }
+            const child = toSymNode(logger, dexChild, this, env, false);
+            return child;
+        }
+    }
+    // Parent
+    addParent(parent, safe = true) {
+        if (parent !== undefined) {
+            if (this._parents === undefined) {
+                this._parents = [];
+            }
+            if (safe && this._parents.indexOf(parent) === -1) {
+                return;
+            }
+            this._parents.push(parent);
+        }
+    }
+    invalidateParent(parent, removed) {
+        const invalidation = [];
+        appendInvalidation(invalidation, this, removed);
+        invalidate(parent, invalidation, true);
+    }
+    invalidate(removed) {
+        const invalidation = [];
+        appendInvalidation(invalidation, this, removed);
+        invalidate(this, invalidation, true);
+    }
+    // Env
+    importEnv(ascend = true) {
+        const obj = this.symDexObj();
+        if (obj instanceof SymDexObj) {
+            return obj.importEnv;
+        }
+        if (!ascend || this._parents === undefined || this._parents.length === 0) {
+            return;
+        }
+        const env = this._parents[0].importEnv(ascend);
+        if (env instanceof SymImportEnv) {
+            this.setImportEnv(env);
+        }
+        return env;
+    }
+    setImportEnv(env) {
+        const obj = this.symDexObj();
+        if (obj instanceof Error) {
+            return obj;
+        }
+        else if (obj instanceof SymDexObj) {
+            obj.importEnv = env;
+        }
+    }
+    // Props
+    set(key, value) {
+        return this.symProps(true).set(key, value);
+    }
+    get(key) {
+        return this.symProps(true).get(key);
+    }
+    has(key) {
+        return this.symProps(true).has(key);
+    }
+    fillPropsAfterLoad() {
+        const symProps = this.symProps(false);
+        if (symProps instanceof Error || symProps === undefined) {
+            return symProps;
+        }
+        const requiredKeys = [
+            SYM_GEOMETRY_KEY,
+            SYM_STRUCTURAL_KEY,
+            SYM_NODE_KEY,
+            SYM_LOCAL_BOUND_KEY,
+        ];
+        for (const key of requiredKeys) {
+            if (!symProps.has(key)) {
+                symProps.set(key, undefined);
+            }
+        }
+    }
+    hasDexComponent(key) {
+        const obj = this.dexObj();
+        if (obj instanceof Error) {
+            return obj;
+        }
+        else if (obj === undefined) {
+            return false;
+        }
+        return obj.has(key);
+    }
+    breakDexConnection(loadChildren = true, descend = true) {
+        const obj = this.dexObj();
+        if (obj === undefined) {
+            return;
+        }
+        const env = this.importEnv();
+        if (env === undefined) {
+            throw Error("[breakDexConnection] could not get env!");
+        }
+        this._breakDexConnection(env, loadChildren, descend);
+    }
+    _breakDexConnection(env, loadChildren, descend) {
+        // console.warn(`SymNode._breakDexConnection ${env} ${descend}`);
+    }
+    dexObj() {
+        const obj = this.symDexObj();
+        return obj && obj.dexObj;
+    }
+    symDexObj() {
+        const component = this.getComponent("symDexObj");
+        if (component instanceof SymDexObj) {
+            return component;
+        }
+    }
+    symGMaterial(safe) {
+        const component = this.getComponent("symGMaterial");
+        if (component instanceof SymGMaterial) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymGMaterial();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symGMaterialSelector(safe) {
+        const component = this.getComponent("symGMaterialSelector");
+        if (component instanceof SymGMaterialSelector) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymGMaterialSelector();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symMesh(safe) {
+        const component = this.getComponent("symMesh");
+        if (component instanceof SymMesh) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymMesh();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symSphere(safe) {
+        const component = this.getComponent("symSphere");
+        if (component instanceof SymSphere) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymSphere();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symBox(safe) {
+        const component = this.getComponent("symBox");
+        if (component instanceof SymBox) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymBox();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symPlane(safe) {
+        const component = this.getComponent("symPlane");
+        if (component instanceof SymPlane) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymPlane();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symProps(safe) {
+        const component = this.getComponent("symProps");
+        if (component instanceof SymProps) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymProps();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symReps(safe) {
+        const component = this.getComponent("symReps");
+        if (component instanceof SymReps) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymReps();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symTags(safe) {
+        const component = this.getComponent("symTags");
+        if (component instanceof SymTags) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymTags();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symTransform(safe) {
+        const component = this.getComponent("symTransform");
+        if (component instanceof SymTransform) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymTransform();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    symUVMapper(safe) {
+        const component = this.getComponent("symUVMapper");
+        if (component instanceof SymUVMapper) {
+            return component;
+        }
+        else if (safe) {
+            const component = new SymUVMapper();
+            this.addComponent(component);
+            return component;
+        }
+    }
+    getMeasure() {
+        const component = this.components.get("symMeasure");
+        if (component instanceof SymMeasure) {
+            return component;
+        }
+    }
+    isStretch(logger, detailLevel) {
+        let isStretch = this._isStretch.get(detailLevel);
+        if (isStretch === undefined) {
+            isStretch = symNodeIsStretch(logger, this, detailLevel);
+            this._isStretch.set(detailLevel, isStretch);
+        }
+        return isStretch;
+    }
+    // Components
+    getComponent(key) {
+        return this.components.get(key);
+    }
+    addComponent(component, invalidate = true) {
+        if (invalidate && component.breaksDex() && this.hasDexComponent(component.id)) {
+            this.breakDexConnection(false);
+        }
+        if (component.node && component.node !== this) {
+            throw Error("[SymNode.addComponent] component already has node.");
+            // component = component.copy();
+        }
+        if (this._children !== undefined) {
+            const features = component.features();
+            if (features !== undefined && features.has("children")) {
+                throw Error("[SymNode.addComponent] node already has children");
+            }
+        }
+        component.addComponent(this, invalidate);
+        this.components.set(component.id, component);
+        component.componentAdded(invalidate);
+    }
+    hasComponent(key) {
+        return this.components.has(key);
+    }
+    removeComponent(key, invalidate = true) {
+        throw Error(`SymNode.removeComponent ${key} ${invalidate}`);
+    }
+    loadComponents(logger, force = false) {
+        const obj = this.dexObj();
+        if (obj === undefined || obj.props === undefined) {
+            return;
+        }
+        const env = this.importEnv();
+        let breakDex = false;
+        for (const key of obj.props.keys()) {
+            const prop = obj.get(key);
+            if (prop instanceof DexObj) {
+                const breaks = this.loadComponent(logger, key, prop, env, force);
+                if (breaks) {
+                    breakDex = true;
+                }
+            }
+        }
+        this.prepareAfterLoad();
+        if (breakDex) {
+            this.breakDexConnection();
+        }
+    }
+    loadComponent(logger, key, obj, env, force = false) {
+        if (env === undefined) {
+            env = this.importEnv();
+        }
+        if (env === undefined) {
+            throw logger.errorAsObject("[loadComponentObj] could not get env!");
+        }
+        else if (key === "children") {
+            return false;
+        }
+        else if (loadLegacyComponent(logger, this, key, obj, env, force)) {
+            return true;
+        }
+        const type = obj.type;
+        if (type === undefined) {
+            throw logger.errorAsObject("[loadComponentObj] obj has no type!");
+        }
+        const component = instantiate(type);
+        if (component instanceof SymComponent) {
+            this.addComponent(component, false);
+            component.load(logger, obj, env, force);
+        }
+        return false;
+    }
+    prepareAfterLoad() {
+        this.buildFeatures();
+        this.fillPropsAfterLoad();
+    }
+    features(create = false) {
+        const features = this.get(SYM_FEATURES_KEY);
+        if (features instanceof Map) {
+            return features;
+        }
+        else if (create) {
+            const features = new Map();
+            this.set(SYM_FEATURES_KEY, features);
+            return features;
+        }
+        throw Error("no features");
+    }
+    featureProviderKey(feature) {
+        return this.features().get(feature);
+    }
+    featureProvider(feature) {
+        const key = this.featureProviderKey(feature);
+        if (key === undefined) {
+            return;
+        }
+        return this.getComponent(key);
+    }
+    buildFeatures() {
+        const features = new Map();
+        for (const component of this.components.values()) {
+            const cFeatures = component.features();
+            if (cFeatures === undefined) {
+                continue;
+            }
+            for (const feature of cFeatures) {
+                features.set(feature, component.id);
+            }
+        }
+        this.set(SYM_FEATURES_KEY, features);
+        return features;
+    }
+    addFeaturesFrom(component) {
+        const features = component.features();
+        if (features === undefined || features.size === 0) {
+            return;
+        }
+        const nodeFeatures = this.features(true);
+        for (const feature of features) {
+            const key = this.featureProviderKey(feature);
+            if (key !== undefined) {
+                this.removeComponent(key, false);
+            }
+            nodeFeatures.set(feature, component.id);
+        }
+        if (features.has("mesh")) {
+            console.warn("mesh cache should be invalidated!" + component);
+        }
+    }
+    childrenProvider() {
+        return this.featureProvider("children");
+    }
+    meshProvider() {
+        return this.featureProvider("mesh");
+    }
+    get3DTmp(logger, detail) {
+        return findMeshNodes(logger, this, detail, [], []);
+    }
+    toString() {
+        return `SymNode("${this.id}")`;
+    }
+}
+export function toSymNode(logger, obj, parent, env, putImportEnv = false) {
+    if (env !== undefined) {
+        const node = env.sharedNodeMap.get(obj);
+        if (node instanceof SymNode) {
+            if (parent) {
+                parent.addChild(logger, node, false);
+            }
+            return node;
+        }
+    }
+    switch (obj.type) {
+        case "node":
+            return toSymBasicNode(logger, obj, parent, env, putImportEnv);
+        case "xRefNode":
+            return toSymXRefNode(obj, parent, env, putImportEnv);
+        case "symFile":
+            return toSymFileRoot(logger, obj, parent);
+    }
+    throw logger.errorAsObject("[toSymNode] Unknown obj.type:", obj.type);
+}
+function toSymBasicNode(logger, obj, parent, env, putImportEnv = false) {
+    if (env === undefined) {
+        throw logger.errorAsObject("[toSymBasicNode] no env");
+    }
+    if (obj.id === undefined) {
+        throw logger.errorAsObject("[toSymBasicNode] obj.id is undefined");
+    }
+    const node = new SymNode(obj.id);
+    node.addComponent(new SymDexObj(obj, env.fileVersion, env), false);
+    env.sharedNodeMap.set(obj, node);
+    if (parent !== undefined) {
+        parent.addChild(logger, node, false);
+    }
+    node.loadComponents(logger);
+    return node;
+}
+function toSymXRefNode(_obj, _parent, _env, _putImportEnv = false) {
+    throw Error("[toSymXRefNode]");
+}
+function toSymFileRoot(logger, obj, parent) {
+    const version = obj.get("version");
+    const semver = loadVersion(version);
+    // Enable to get CmSym version statistics in the Exerciser
+    // logger.info("CmSym version " + semver.toDisplayString());
+    const env = new SymImportEnv(semver);
+    const sym = obj.get("sym");
+    if (!(sym instanceof DexObj)) {
+        throw Error(`sym: ${sym} is not a DexObj`);
+    }
+    return toSymNode(logger, sym, parent, env, true);
+}
+function loadVersion(obj) {
+    if (obj instanceof DexObj) {
+        return Semver.fromDex(obj);
+    }
+    if (obj instanceof DexVersion) {
+        return obj.toSemver();
+    }
+    throw Error(`obj: ${obj} can't load version`);
+}
+export function loadSymFile(logger, url, manager, abortSignal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const root = yield manager.load(logger, url, abortSignal);
+        return makeSymFromDex(logger, root);
+    });
+}
+export function makeSymFromDex(logger, root) {
+    const node = toSymNode(logger, root);
+    if (!(node instanceof SymNode)) {
+        throw Error(`node: ${node} is not a SymNode`);
+    }
+    node.ensureChildrenLoaded(logger);
+    return node;
+}
+function symNodeIsStretch(logger, symNode, detailLevel) {
+    const symMeasure = symNode.getMeasure();
+    if (symMeasure === undefined) {
+        return false;
+    }
+    const children = symNode.children(logger, true, true);
+    let nodeName;
+    for (const [name, node] of children) {
+        if (name.startsWith("3D") || name.startsWith("2D")) {
+            const symReps = node.symReps(true);
+            const details = symReps._details;
+            if (details === undefined) {
+                continue;
+            }
+            const detailMask = details.values().next().value;
+            if (detailMask.includes(detailLevel)) {
+                nodeName = name;
+                break;
+            }
+        }
+    }
+    if (nodeName === undefined) {
+        logger.warn(`No 3D/2D SymNode which covers the detailLevel ${detailLevel} found`);
+        return false;
+    }
+    const node = children.get(nodeName);
+    if (node === undefined) {
+        return false;
+    }
+    const progsNode = node.components.get("symProgs");
+    if (progsNode === undefined) {
+        return false;
+    }
+    const symProgs = progsNode;
+    for (const prog of symProgs.progs) {
+        if (prog.isStretch) {
+            return true;
+        }
+    }
+    return false;
+}