@configura/web-core 1.3.0-alpha.0 → 1.3.0-alpha.4

package/dist/cm/core3D/UVMapEnv.d.ts

@@ -1,18 +1,18 @@
-import { Point } from "../geometry/Point.js";
-import { UVTransformer } from "./UVTransformer.js";
-export declare enum UVMapperType {
-    Box = 0,
-    Spherical = 1,
-    Planar = 2,
-    Cylindrical = 3
-}
-export declare function castUVMapperType(name: string): UVMapperType | undefined;
-export declare function fcastUVMapperType(name: string): UVMapperType;
-export declare class UVMapEnv {
-    type: UVMapperType;
-    transforms?: UVTransformer[] | undefined;
-    normal: Point;
-    uniform: boolean;
-    constructor(type: UVMapperType, transforms?: UVTransformer[] | undefined, normal?: Point, uniform?: boolean);
-}
+import { Point } from "../geometry/Point.js";
+import { UVTransformer } from "./UVTransformer.js";
+export declare enum UVMapperType {
+    Box = 0,
+    Spherical = 1,
+    Planar = 2,
+    Cylindrical = 3
+}
+export declare function castUVMapperType(name: string): UVMapperType | undefined;
+export declare function fcastUVMapperType(name: string): UVMapperType;
+export declare class UVMapEnv {
+    type: UVMapperType;
+    transforms?: UVTransformer[] | undefined;
+    normal: Point;
+    uniform: boolean;
+    constructor(type: UVMapperType, transforms?: UVTransformer[] | undefined, normal?: Point, uniform?: boolean);
+}
 //# sourceMappingURL=UVMapEnv.d.ts.map

package/dist/cm/core3D/UVMapEnv.js

@@ -1,35 +1,35 @@
-import { Point } from "../geometry/Point.js";
-export var UVMapperType;
-(function (UVMapperType) {
-    UVMapperType[UVMapperType["Box"] = 0] = "Box";
-    UVMapperType[UVMapperType["Spherical"] = 1] = "Spherical";
-    UVMapperType[UVMapperType["Planar"] = 2] = "Planar";
-    UVMapperType[UVMapperType["Cylindrical"] = 3] = "Cylindrical";
-})(UVMapperType || (UVMapperType = {}));
-export function castUVMapperType(name) {
-    switch (name) {
-        case "box":
-            return UVMapperType.Box;
-        case "spherical":
-            return UVMapperType.Spherical;
-        case "planar":
-            return UVMapperType.Planar;
-        case "cylindrical":
-            return UVMapperType.Cylindrical;
-    }
-}
-export function fcastUVMapperType(name) {
-    const type = castUVMapperType(name);
-    if (type === undefined) {
-        throw new Error(`unknown UVMapperType: ${name}`);
-    }
-    return type;
-}
-export class UVMapEnv {
-    constructor(type, transforms, normal = new Point(0, 0, 0), uniform = true) {
-        this.type = type;
-        this.transforms = transforms;
-        this.normal = normal;
-        this.uniform = uniform;
-    }
-}
+import { Point } from "../geometry/Point.js";
+export var UVMapperType;
+(function (UVMapperType) {
+    UVMapperType[UVMapperType["Box"] = 0] = "Box";
+    UVMapperType[UVMapperType["Spherical"] = 1] = "Spherical";
+    UVMapperType[UVMapperType["Planar"] = 2] = "Planar";
+    UVMapperType[UVMapperType["Cylindrical"] = 3] = "Cylindrical";
+})(UVMapperType || (UVMapperType = {}));
+export function castUVMapperType(name) {
+    switch (name) {
+        case "box":
+            return UVMapperType.Box;
+        case "spherical":
+            return UVMapperType.Spherical;
+        case "planar":
+            return UVMapperType.Planar;
+        case "cylindrical":
+            return UVMapperType.Cylindrical;
+    }
+}
+export function fcastUVMapperType(name) {
+    const type = castUVMapperType(name);
+    if (type === undefined) {
+        throw new Error(`unknown UVMapperType: ${name}`);
+    }
+    return type;
+}
+export class UVMapEnv {
+    constructor(type, transforms, normal = new Point(0, 0, 0), uniform = true) {
+        this.type = type;
+        this.transforms = transforms;
+        this.normal = normal;
+        this.uniform = uniform;
+    }
+}

package/dist/cm/core3D/UVTransformer.d.ts

@@ -1,6 +1,6 @@
-import { Transform2D } from "../geometry/Transform2D.js";
-export declare class UVTransformer {
-    transform: Transform2D;
-    constructor(transform: Transform2D);
-}
+import { Transform2D } from "../geometry/Transform2D.js";
+export declare class UVTransformer {
+    transform: Transform2D;
+    constructor(transform: Transform2D);
+}
 //# sourceMappingURL=UVTransformer.d.ts.map

package/dist/cm/core3D/UVTransformer.js

@@ -1,5 +1,5 @@
-export class UVTransformer {
-    constructor(transform) {
-        this.transform = transform;
-    }
-}
+export class UVTransformer {
+    constructor(transform) {
+        this.transform = transform;
+    }
+}

package/dist/cm/core3D/instantiateUVMapper.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from "@configura/web-utilities";
-import { DummyUVMapper } from "./DummyUVMapper.js";
-export declare function instantiateUVMapper(logger: Logger, className: string): DummyUVMapper;
+import { Logger } from "@configura/web-utilities";
+import { DummyUVMapper } from "./DummyUVMapper.js";
+export declare function instantiateUVMapper(logger: Logger, className: string): DummyUVMapper;
 //# sourceMappingURL=instantiateUVMapper.d.ts.map

package/dist/cm/core3D/instantiateUVMapper.js

@@ -1,5 +1,5 @@
-import { DummyUVMapper } from "./DummyUVMapper.js";
-export function instantiateUVMapper(logger, className) {
-    logger.warn("UV-Mapping not implemented. UV-maps must be pre-baked.", className);
-    return new DummyUVMapper();
-}
+import { DummyUVMapper } from "./DummyUVMapper.js";
+export function instantiateUVMapper(logger, className) {
+    logger.warn("UV-Mapping not implemented. UV-maps must be pre-baked.", className);
+    return new DummyUVMapper();
+}

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

@@ -1,10 +1,10 @@
-import { SymInv } from "./SymInv.js";
-import { SymNode } from "./SymNode.js";
-export declare class InvalidationEnv {
-    node: SymNode;
-    invalidation: SymInv[];
-    n: number;
-    constructor(node: SymNode, invalidation: SymInv[], n?: number);
-    dump(): void;
-}
+import { SymInv } from "./SymInv.js";
+import { SymNode } from "./SymNode.js";
+export declare class InvalidationEnv {
+    node: SymNode;
+    invalidation: SymInv[];
+    n: number;
+    constructor(node: SymNode, invalidation: SymInv[], n?: number);
+    dump(): void;
+}
 //# sourceMappingURL=InvalidationEnv.d.ts.map

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

@@ -1,13 +1,13 @@
-export class InvalidationEnv {
-    constructor(node, invalidation, n = 0) {
-        this.node = node;
-        this.invalidation = invalidation;
-        this.n = n;
-    }
-    dump() {
-        console.log(`${" ".repeat(this.n)}${this.node}`);
-        for (const inv of this.invalidation) {
-            console.log(`${" ".repeat(this.n + 1)}${inv}`);
-        }
-    }
-}
+export class InvalidationEnv {
+    constructor(node, invalidation, n = 0) {
+        this.node = node;
+        this.invalidation = invalidation;
+        this.n = n;
+    }
+    dump() {
+        console.log(`${" ".repeat(this.n)}${this.node}`);
+        for (const inv of this.invalidation) {
+            console.log(`${" ".repeat(this.n + 1)}${inv}`);
+        }
+    }
+}

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

@@ -1,10 +1,10 @@
-import { Semver } from "../../io/Semver.js";
-import { DexObj } from "../dex/DexObj.js";
-import { SymNode } from "./SymNode.js";
-export declare class SymImportEnv {
-    fileVersion: Semver;
-    sharedNodeMap: Map<DexObj, SymNode>;
-    constructor(fileVersion: Semver);
-    copy(): SymImportEnv;
-}
+import { Semver } from "../../io/Semver.js";
+import { DexObj } from "../dex/DexObj.js";
+import { SymNode } from "./SymNode.js";
+export declare class SymImportEnv {
+    fileVersion: Semver;
+    sharedNodeMap: Map<DexObj, SymNode>;
+    constructor(fileVersion: Semver);
+    copy(): SymImportEnv;
+}
 //# sourceMappingURL=SymImportEnv.d.ts.map

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

@@ -1,9 +1,9 @@
-export class SymImportEnv {
-    constructor(fileVersion) {
-        this.fileVersion = fileVersion;
-        this.sharedNodeMap = new Map();
-    }
-    copy() {
-        return new SymImportEnv(this.fileVersion);
-    }
-}
+export class SymImportEnv {
+    constructor(fileVersion) {
+        this.fileVersion = fileVersion;
+        this.sharedNodeMap = new Map();
+    }
+    copy() {
+        return new SymImportEnv(this.fileVersion);
+    }
+}

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

@@ -1,9 +1,9 @@
-import { SymNode } from "./SymNode.js";
-export declare class SymInv {
-    needToInvalidate(node: SymNode): boolean;
-    skip(node: SymNode): boolean;
-    propagate(): boolean;
-    invalidate(node: SymNode): void;
-    toString(): string;
-}
+import { SymNode } from "./SymNode.js";
+export declare class SymInv {
+    needToInvalidate(node: SymNode): boolean;
+    skip(node: SymNode): boolean;
+    propagate(): boolean;
+    invalidate(node: SymNode): void;
+    toString(): string;
+}
 //# sourceMappingURL=SymInv.d.ts.map

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

@@ -1,15 +1,15 @@
-export class SymInv {
-    needToInvalidate(node) {
-        return true;
-    }
-    skip(node) {
-        return false;
-    }
-    propagate() {
-        return true;
-    }
-    invalidate(node) { }
-    toString() {
-        return `SymInv()`;
-    }
-}
+export class SymInv {
+    needToInvalidate(node) {
+        return true;
+    }
+    skip(node) {
+        return false;
+    }
+    propagate() {
+        return true;
+    }
+    invalidate(node) { }
+    toString() {
+        return `SymInv()`;
+    }
+}

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

@@ -1,86 +1,86 @@
-import { Logger } from "@configura/web-utilities";
-import { DetailLevel } from "../../geometry/DetailMask.js";
-import { DexManager } from "../dex/DexManager.js";
-import { DexObj } from "../dex/DexObj.js";
-import { SymBox } from "./components/SymBox.js";
-import { DexObjKey, SymComponent, SymComponentKey } from "./components/SymComponent.js";
-import { SymDexObj } from "./components/SymDexObj.js";
-import { SymGMaterial } from "./components/SymGMaterial.js";
-import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
-import { SymMesh } from "./components/SymMesh.js";
-import { SymProps } 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 { SymImportEnv } from "./SymImportEnv.js";
-export declare class SymNode {
-    id: string;
-    _children?: Map<string, SymNode>;
-    components: Map<string, SymComponent>;
-    _parents?: SymNode[];
-    constructor(id: string);
-    setId(logger: Logger, newId: string): void;
-    children(logger: Logger, safe: true, load: boolean): Map<string, SymNode>;
-    children(logger: Logger, safe?: boolean, load?: boolean): Map<string, SymNode> | undefined;
-    ensureChildrenLoaded(logger: Logger): void;
-    dexChildrenCount(): number;
-    loadDexChildren(logger: Logger): void;
-    addChild(logger: Logger, child: SymNode, invalidate?: boolean): void;
-    loadChild(logger: Logger, dexChildren: DexObj, id: string, env?: SymImportEnv): SymNode | undefined;
-    addParent(parent?: SymNode, safe?: boolean): void;
-    invalidateParent(parent: SymNode, removed: boolean): void;
-    invalidate(removed: boolean): void;
-    importEnv(ascend?: boolean): SymImportEnv | undefined;
-    setImportEnv(env: SymImportEnv): (SymDexObj & Error) | undefined;
-    set(key: string, value: any): void;
-    get(key: string): unknown;
-    has(key: string): boolean;
-    fillPropsAfterLoad(): (SymProps & Error) | undefined;
-    hasDexComponent(key: string): boolean | (DexObj & Error);
-    breakDexConnection(loadChildren?: boolean, descend?: boolean): void;
-    _breakDexConnection(env: SymImportEnv, loadChildren: boolean, descend: boolean): void;
-    dexObj(): DexObj | undefined;
-    symDexObj(): SymDexObj | undefined;
-    symGMaterial(safe: true): SymGMaterial;
-    symGMaterial(safe?: boolean): SymGMaterial | undefined;
-    symGMaterialSelector(safe: true): SymGMaterialSelector;
-    symGMaterialSelector(safe?: boolean): SymGMaterialSelector | undefined;
-    symMesh(safe: true): SymMesh;
-    symMesh(safe?: boolean): SymMesh | undefined;
-    symSphere(safe: true): SymSphere;
-    symSphere(safe?: boolean): SymSphere | undefined;
-    symBox(safe: true): SymBox;
-    symBox(safe?: boolean): SymBox | undefined;
-    symProps(safe: true): SymProps;
-    symProps(safe?: boolean): SymProps | undefined;
-    symReps(safe: true): SymReps;
-    symReps(safe?: boolean): SymReps | undefined;
-    symTags(safe: true): SymTags;
-    symTags(safe?: boolean): SymTags | undefined;
-    symTransform(safe: true): SymTransform;
-    symTransform(safe?: boolean): SymTransform | undefined;
-    symUVMapper(safe: true): SymUVMapper;
-    symUVMapper(safe?: boolean): SymUVMapper | undefined;
-    getComponent(key: SymComponentKey): SymComponent | undefined;
-    addComponent(component: SymComponent, invalidate?: boolean): void;
-    hasComponent(key: SymComponentKey | DexObjKey): boolean;
-    removeComponent(key: SymComponentKey, invalidate?: boolean): void;
-    loadComponents(logger: Logger, force?: boolean): void;
-    loadComponent(logger: Logger, key: SymComponentKey | DexObjKey, obj: DexObj, env?: SymImportEnv, force?: boolean): boolean;
-    prepareAfterLoad(): void;
-    features(create?: boolean): Map<string, SymComponentKey>;
-    featureProviderKey(feature: string): SymComponentKey | undefined;
-    featureProvider(feature: string): SymComponent | undefined;
-    buildFeatures(): Map<string, SymComponentKey>;
-    addFeaturesFrom(component: SymComponent): void;
-    childrenProvider(): SymComponent | undefined;
-    meshProvider(): SymComponent | undefined;
-    get3DTmp(logger: Logger, detail: DetailLevel): import("./components/mesh.js").TaggedNode[];
-    toString(): string;
-}
-export declare function toSymNode(logger: Logger, obj: DexObj, parent?: SymNode, env?: SymImportEnv, putImportEnv?: boolean): SymNode;
-export declare function loadSymFile(logger: Logger, url: string, manager: DexManager, abortSignal?: AbortSignal): Promise<SymNode>;
-export declare function makeSymFromDex(logger: Logger, root: DexObj): SymNode;
+import { Logger } from "@configura/web-utilities";
+import { DetailLevel } from "../../geometry/DetailMask.js";
+import { DexManager } from "../dex/DexManager.js";
+import { DexObj } from "../dex/DexObj.js";
+import { SymBox } from "./components/SymBox.js";
+import { DexObjKey, SymComponent, SymComponentKey } from "./components/SymComponent.js";
+import { SymDexObj } from "./components/SymDexObj.js";
+import { SymGMaterial } from "./components/SymGMaterial.js";
+import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
+import { SymMesh } from "./components/SymMesh.js";
+import { SymProps } 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 { SymImportEnv } from "./SymImportEnv.js";
+export declare class SymNode {
+    id: string;
+    _children?: Map<string, SymNode>;
+    components: Map<string, SymComponent>;
+    _parents?: SymNode[];
+    constructor(id: string);
+    setId(logger: Logger, newId: string): void;
+    children(logger: Logger, safe: true, load: boolean): Map<string, SymNode>;
+    children(logger: Logger, safe?: boolean, load?: boolean): Map<string, SymNode> | undefined;
+    ensureChildrenLoaded(logger: Logger): void;
+    dexChildrenCount(): number;
+    loadDexChildren(logger: Logger): void;
+    addChild(logger: Logger, child: SymNode, invalidate?: boolean): void;
+    loadChild(logger: Logger, dexChildren: DexObj, id: string, env?: SymImportEnv): SymNode | undefined;
+    addParent(parent?: SymNode, safe?: boolean): void;
+    invalidateParent(parent: SymNode, removed: boolean): void;
+    invalidate(removed: boolean): void;
+    importEnv(ascend?: boolean): SymImportEnv | undefined;
+    setImportEnv(env: SymImportEnv): (SymDexObj & Error) | undefined;
+    set(key: string, value: any): void;
+    get(key: string): unknown;
+    has(key: string): boolean;
+    fillPropsAfterLoad(): (SymProps & Error) | undefined;
+    hasDexComponent(key: string): boolean | (DexObj & Error);
+    breakDexConnection(loadChildren?: boolean, descend?: boolean): void;
+    _breakDexConnection(env: SymImportEnv, loadChildren: boolean, descend: boolean): void;
+    dexObj(): DexObj | undefined;
+    symDexObj(): SymDexObj | undefined;
+    symGMaterial(safe: true): SymGMaterial;
+    symGMaterial(safe?: boolean): SymGMaterial | undefined;
+    symGMaterialSelector(safe: true): SymGMaterialSelector;
+    symGMaterialSelector(safe?: boolean): SymGMaterialSelector | undefined;
+    symMesh(safe: true): SymMesh;
+    symMesh(safe?: boolean): SymMesh | undefined;
+    symSphere(safe: true): SymSphere;
+    symSphere(safe?: boolean): SymSphere | undefined;
+    symBox(safe: true): SymBox;
+    symBox(safe?: boolean): SymBox | undefined;
+    symProps(safe: true): SymProps;
+    symProps(safe?: boolean): SymProps | undefined;
+    symReps(safe: true): SymReps;
+    symReps(safe?: boolean): SymReps | undefined;
+    symTags(safe: true): SymTags;
+    symTags(safe?: boolean): SymTags | undefined;
+    symTransform(safe: true): SymTransform;
+    symTransform(safe?: boolean): SymTransform | undefined;
+    symUVMapper(safe: true): SymUVMapper;
+    symUVMapper(safe?: boolean): SymUVMapper | undefined;
+    getComponent(key: SymComponentKey): SymComponent | undefined;
+    addComponent(component: SymComponent, invalidate?: boolean): void;
+    hasComponent(key: SymComponentKey | DexObjKey): boolean;
+    removeComponent(key: SymComponentKey, invalidate?: boolean): void;
+    loadComponents(logger: Logger, force?: boolean): void;
+    loadComponent(logger: Logger, key: SymComponentKey | DexObjKey, obj: DexObj, env?: SymImportEnv, force?: boolean): boolean;
+    prepareAfterLoad(): void;
+    features(create?: boolean): Map<string, SymComponentKey>;
+    featureProviderKey(feature: string): SymComponentKey | undefined;
+    featureProvider(feature: string): SymComponent | undefined;
+    buildFeatures(): Map<string, SymComponentKey>;
+    addFeaturesFrom(component: SymComponent): void;
+    childrenProvider(): SymComponent | undefined;
+    meshProvider(): SymComponent | undefined;
+    get3DTmp(logger: Logger, detail: DetailLevel): import("./components/mesh.js").TaggedNode[];
+    toString(): string;
+}
+export declare function toSymNode(logger: Logger, obj: DexObj, parent?: SymNode, env?: SymImportEnv, putImportEnv?: boolean): SymNode;
+export declare function loadSymFile(logger: Logger, url: string, manager: DexManager, abortSignal?: AbortSignal): Promise<SymNode>;
+export declare function makeSymFromDex(logger: Logger, root: DexObj): SymNode;
 //# sourceMappingURL=SymNode.d.ts.map