archgine 1.0.36 → 1.0.39

package/lib/applications/app-cvs.d.ts

@@ -0,0 +1,16 @@
+import { Application, IApplicationConfig } from './application';
+import { MainScene } from '../scenes/main-scene';
+import { ITree } from '../interfaces';
+import { Adapter } from '../extras/adapter';
+export declare class AppCvs<Config extends IApplicationConfig> extends Application<Config> {
+    params: Config;
+    adapter: Adapter;
+    mainScene: MainScene<Config>;
+    constructor(config?: Config);
+    destroy(): void;
+    load(url?: string, layers?: string[]): Promise<void>;
+    getLayers(lv?: number): ITree[];
+    trans2MainScene(): void;
+    fullScreen(): void;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
+}

package/lib/applications/app-offscreen.d.ts

@@ -1,14 +1,33 @@
-import { default as EventDispatcher } from '../core/event-dispatcher';
 import { IApplicationConfig } from './application';
-export interface IAppOffscreenConfig extends IApplicationConfig {
-}
-export declare class AppOffscreen<Config extends IAppOffscreenConfig> extends EventDispatcher {
-    readonly name: string;
+import { OpeView } from '../core/ope-view';
+import { APP_ENUM, ITree } from '../interfaces';
+import { default as EventDispatcher } from '../core/event-dispatcher';
+import { default as Box2 } from '../math/box2';
+export declare class AppOffscreen<Config extends IApplicationConfig> extends EventDispatcher {
     params: Config;
-    private readonly runningHandler;
+    cvs: OffscreenCanvas;
+    worker: Worker;
+    view: OpeView<Config>;
+    boundingBox: Box2;
+    readonly workerMessageHandler: (e: MessageEvent) => void;
+    readonly cameraHandler: (e: MessageEvent) => void;
+    readonly runningHandler: (time: DOMHighResTimeStamp) => void;
     constructor(config?: Config);
     destroy(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleWorkerMessage(e: MessageEvent): void;
+    handleCameraChanged(e: MessageEvent): void;
+    promiseWorkerResponse<T>(task: APP_ENUM, data: any): Promise<T>;
+    resize(): void;
+    load(url: string, layers?: string[]): Promise<void>;
+    getLayers(lv?: number): Promise<ITree[]>;
+    fullscreen(): Promise<void>;
+    saveCameraPosition(id?: string): void;
+    restoreCameraPosition(id?: string): void;
+    clearCameraPosition(id?: string): void;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
     start(): void;
-    /** @description application's lifeCycle */
-    running(): void;
+    running(time: DOMHighResTimeStamp): void;
+    stop(): void;
 }

package/lib/applications/application.d.ts

@@ -1,17 +1,31 @@
+import { IRenderer2, IRenderer2Config } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { IRenderer2Config } from '../interfaces';
-import { default as Scene } from '../scenes/scene';
 import { default as Box2 } from '../math/box2';
-import { default as Renderer2 } from '../renders/renderer2';
 import { View } from '../core/view';
+import { EffectComposer } from '../effects/effect-composer';
+import { default as Scene } from '../scenes/scene';
 export interface IApplicationConfig extends IRenderer2Config {
     frameInterval?: number;
     syncDelay?: number;
     animateDuration?: number;
+    defaultFill?: string;
+    defaultStroke?: string;
+    infoFill?: string;
+    infoStroke?: string;
+    primaryFill?: string;
+    primaryStroke?: string;
+    successFill?: string;
+    successStroke?: string;
+    warningFill?: string;
+    warningStroke?: string;
+    dangerFill?: string;
+    dangerStroke?: string;
+    activeFill?: string;
+    activeStroke?: string;
 }
 /**
  * @author Dio Zhu
- * @since 2024.8.22
+ * @since 2024.11.13
  */
 export declare abstract class Application<Config extends IApplicationConfig> extends EventDispatcher {
     name: string;
@@ -19,13 +33,15 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     scenes: Scene[];
     nextScenes: Scene[];
     nextBoundingBox: Box2;
-    renderer: Renderer2<Config>;
-    view: View<Config>;
-    runningHandler: () => void;
+    loadingScene: Scene;
+    composer: EffectComposer;
+    renderer: IRenderer2;
+    view: View<any>;
+    readonly runningHandler: (time: DOMHighResTimeStamp) => void;
     protected constructor(config?: Config);
+    get isLoadingScene(): boolean;
     destroy(): void;
-    setViewAreaLimit(v: number): void;
-    updateScenes(): void;
+    trans2LoadingScene(): void;
     hasScene(scene: Scene): boolean;
     pushScene(scene: Scene): void;
     clearScenes(): void;
@@ -35,5 +51,6 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     trans2Scenes(...scenes: Scene[]): void;
     start(): void;
     /** @description application's lifeCycle */
-    running(): void;
+    running(time: DOMHighResTimeStamp): void;
+    stop(): void;
 }

package/lib/controls/interactive-controls.d.ts

@@ -1,10 +1,10 @@
 import { OrbitControls } from './orbit-controls';
-import { ICamera2, ICanvas } from '../interfaces';
+import { ICamera2 } from '../interfaces';
 export declare class InteractiveControls extends OrbitControls {
     name: string;
     mouseButtons: any;
     private readonly clickHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     bindMapEvents(): void;
     unbindMapEvents(): void;

package/lib/controls/orbit-controller.d.ts

@@ -1,6 +1,6 @@
-import { ICamera2, IVector2 } from '../interfaces';
+import { ICamera2, IOrbitController, IVector2 } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-export declare class OrbitController extends EventDispatcher {
+export declare class OrbitController extends EventDispatcher implements IOrbitController {
     name: string;
     isSvg: boolean;
     dom: HTMLElement;
@@ -152,5 +152,6 @@ export declare enum EventsEnum {
     PINCH_OUT = "pinchout",
     SWIPE = "swipe",
     CHANGE_START = "change_start",
-    CHANGE_END = "change_end"
+    CHANGE_END = "change_end",
+    CAMERA_CHANGED = "cameraChanged"
 }

package/lib/controls/orbit-controls.d.ts

@@ -1,6 +1,6 @@
 import { default as Vector2 } from '../math/vector2';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { ICamera2, ICanvas, IMatrix3, IVector2 } from '../interfaces';
+import { ICamera2, IMatrix3, IVector2 } from '../interfaces';
 interface IScene {
 }
 export interface IOrbitControlsConfig {
@@ -22,7 +22,7 @@ export interface IOrbitControlsConfig {
 export declare class OrbitControls extends EventDispatcher {
     name: string;
     camera: ICamera2;
-    domElement: ICanvas;
+    domElement: HTMLElement;
     domOffset: Vector2;
     enableNegateControl: boolean;
     focus: Vector2;
@@ -44,20 +44,22 @@ export declare class OrbitControls extends EventDispatcher {
         ONE: TouchEnum;
         TWO: TouchEnum;
     };
-    private _lastPosition;
     target0: IVector2;
     position0: IVector2;
     scene: IScene | null;
     enabled: boolean;
     state: number;
     EPS: number;
+    scaled: number;
+    rotateTheta: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private _lastPosition;
     private pointers;
     private pointerPositions;
-    scaled: number;
     private rotateStart;
     private rotateEnd;
     private rotateDelta;
-    rotateTheta: number;
     private panStart;
     private panEnd;
     private panDelta;
@@ -66,15 +68,13 @@ export declare class OrbitControls extends EventDispatcher {
     private dollyEnd;
     private dollyDelta;
     private dollyOffset;
-    enableDamping: boolean;
-    dampingFactor: number;
     private readonly contextMenuHandler;
     private readonly pointerDownHandler;
     private readonly pointerUpHandler;
     private readonly pointerCancelHandler;
     private readonly pointerMoveHandler;
     private readonly wheelHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     update(): void;
     pan(deltaX: number, deltaY: number): void;

package/lib/core/camera2.d.ts

@@ -1,28 +1,15 @@
 import { default as Vector2 } from '../math/vector2';
-import { ICamera2, ICamera2Position, IObject2, IVector2 } from '../interfaces';
+import { ICamera2, ICamera2Config, ICamera2Position, IObject2, IPoint2, IVector2 } from '../interfaces';
 import { default as Matrix3 } from '../math/matrix3';
 import { Object2 } from './object2';
 import { default as Box2 } from '../math/box2';
-export interface ICamera2Config {
-    width?: number;
-    height?: number;
-    aspect?: number;
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    eye?: number[];
-    up?: number[];
-    helperEnable?: boolean;
-    flipY?: boolean;
-}
 interface IView {
     enabled: boolean;
     width: number;
     height: number;
     offset: IVector2;
 }
-export default class Camera2<Config extends ICamera2Config = ICamera2Config> extends Object2 implements ICamera2 {
+export default class Camera2<Config extends ICamera2Config> extends Object2 implements ICamera2 {
     readonly isCamera: boolean;
     type: string;
     name: string;
@@ -47,6 +34,7 @@ export default class Camera2<Config extends ICamera2Config = ICamera2Config> ext
     get pixelWidth(): number;
     set(l?: number, r?: number, t?: number, b?: number): void;
     setByBox(box: Box2): void;
+    setTRS(t?: IPoint2, r?: number, s?: number): void;
     resize(): void;
     setSize(w: number, h: number): void;
     getWorldDirection(target: Vector2): Vector2;
@@ -61,7 +49,7 @@ export default class Camera2<Config extends ICamera2Config = ICamera2Config> ext
     toJSON(): any;
     fromJSON(o: any): void;
     clone(): any;
-    copy(source: Camera2, recursive?: boolean): IObject2;
+    copy(source: Camera2<Config>, recursive?: boolean): IObject2;
 }
 export declare enum CAMERA_ENUM {
     UPDATE = "update"

package/lib/core/monitor.d.ts

@@ -9,6 +9,13 @@ interface IMonitorRecord {
 }
 export declare class Monitor {
     static idCounter: number;
+    static children: Monitor[];
+    static isRunning: boolean;
+    static actived: boolean;
+    static duration: number;
+    static lastTime: number;
+    static messages: IMonitorRecord[];
+    static maxLetters: number;
     id: number;
     timers: Map<string, number[]>;
     timersDuration: Map<string, number>;
@@ -16,6 +23,12 @@ export declare class Monitor {
     countersAmount: Map<string, number>;
     out: IMonitorRecord[];
     constructor();
+    static active(duration?: number): void;
+    static add(o: Monitor): void;
+    static remove(o: Monitor): void;
+    static handleStart(): void;
+    static runLoop(): void;
+    static runFrames(): void;
     destroy(): void;
     addTimer(key: string, t?: number, duration?: number): void;
     addTimerDuration(key: string, duration: number): void;
@@ -34,18 +47,5 @@ export declare class Monitor {
     stdDev(durations: number[], avg: number): number;
     fd(d: number): string;
     fx(d: number, l?: number): number;
-    static children: Monitor[];
-    static isRunning: boolean;
-    static actived: boolean;
-    static duration: number;
-    static lastTime: number;
-    static messages: IMonitorRecord[];
-    static maxLetters: number;
-    static active(duration?: number): void;
-    static add(o: Monitor): void;
-    static remove(o: Monitor): void;
-    static handleStart(): void;
-    static runLoop(): void;
-    static runFrames(): void;
 }
 export {};

package/lib/core/object2.d.ts

@@ -1,5 +1,5 @@
 import { default as EventDispatcher } from './event-dispatcher';
-import { IAnimationClip, IBox2, ICamera2, IObject2, IPoint2, IVector2 } from '../interfaces';
+import { IAnimationClip, IBox2, ICamera2, IMatrix3, IObject2, IPoint2, IVector2 } from '../interfaces';
 import { default as Vector2 } from '../math/vector2';
 import { default as Matrix3 } from '../math/matrix3';
 import { default as Box2 } from '../math/box2';
@@ -16,7 +16,6 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     name: string;
     type: string;
     featureKey: string;
-    _version: number;
     parent: IObject2 | undefined;
     children: IObject2[];
     up: Vector2;
@@ -49,13 +48,14 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     animations: IAnimationClip[];
     finalSize?: IPoint2;
     userData: any;
-    [prop: string]: any;
     DefaultUp: Vector2;
+    [prop: string]: any;
     private _autoSort;
     constructor(config?: IObject2Config);
-    set needsUpdate(v: boolean);
+    _version: number;
     get version(): number;
     set version(v: number);
+    set needsUpdate(v: boolean);
     destroy(): void;
     setPosition(v: IVector2): this;
     translate(x: number, y: number): void;
@@ -67,7 +67,7 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     localToWorld(v: Vector2): Vector2;
     worldToLocal(v: Vector2): Vector2;
     lookAt(v: Vector2): void;
-    applyMatrix3(matrix: Matrix3): void;
+    applyMatrix3(matrix: IMatrix3): void;
     updateMatrix(): void;
     updateMatrixWorld(force?: boolean): void;
     updateWorldMatrix(updateParents?: boolean, updateChildren?: boolean): void;

package/lib/core/ope-view.d.ts

@@ -0,0 +1,24 @@
+import { ICamera2, ICamera2Config, ICanvas, IRenderer2Config } from '../interfaces';
+import { IOrbitControlsConfig } from '../controls/orbit-controls';
+import { OrbitController } from '../controls/orbit-controller';
+import { IAxesHelperConfig } from '../helpers/axes-helper';
+import { View } from './view';
+export interface IViewConfig extends IRenderer2Config {
+    name?: string;
+    cvs?: ICanvas;
+    camera?: ICamera2Config;
+    controls?: IOrbitControlsConfig;
+    axesHelper?: IAxesHelperConfig;
+    alignStageCenter?: boolean;
+}
+/**
+ * @author Dio Zhu 2024.8.22
+ */
+export declare class OpeView<Config extends IViewConfig> extends View<Config> {
+    name: string;
+    controller: OrbitController;
+    constructor(config?: Config);
+    destroy(): void;
+    initController(camera?: ICamera2): void;
+    handleCameraChanged(e: any): void;
+}

package/lib/core/view.d.ts

@@ -1,10 +1,10 @@
-import { IBox2, ICamera2, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { IBox2, ICamera2, ICamera2Config, ICamera2Position, ICanvas, IRenderer2Config, IView } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
-import { ICamera2Config } from './camera2';
 import { default as Scene } from '../scenes/scene';
 import { OrbitController } from '../controls/orbit-controller';
 import { default as Box2 } from '../math/box2';
 import { IAxesHelperConfig } from '../helpers/axes-helper';
+import { Tween } from '@tweenjs/tween.js';
 export interface IViewConfig extends IRenderer2Config {
     name?: string;
     cvs?: ICanvas;
@@ -12,6 +12,7 @@ export interface IViewConfig extends IRenderer2Config {
     controls?: IOrbitControlsConfig;
     axesHelper?: IAxesHelperConfig;
     alignStageCenter?: boolean;
+    animateDuration?: number;
 }
 /**
  * @author Dio Zhu 2024.8.22
@@ -20,23 +21,29 @@ export declare class View<Config extends IViewConfig> implements IView {
     name: string;
     params: Config;
     visible: boolean;
-    container: HTMLElement;
     cvs: ICanvas | undefined;
     scene: Scene | undefined;
     scenes: Scene[];
-    camera: ICamera2 | undefined;
+    camera: ICamera2;
     controller?: OrbitController;
+    tween?: Tween;
+    animateDuration: number;
     constructor(config?: Config);
     destroy(): void;
-    initController(camera?: ICamera2, dom?: HTMLElement): void;
+    bindScene(scene: Scene): void;
+    saveCameraPosition(id?: string): void;
+    clearCameraPosition(id?: string): void;
+    restoreCameraPosition(id?: string): void;
+    fullscreen(padding?: number, animate?: boolean): void;
     handleCameraChanged(e: any): void;
     reset(): void;
-    bindScene(scene: Scene): void;
-    resetCameraByBoundingBox(box: IBox2, animate?: boolean): void;
-    computeScenesBoundingBox(scenes: Scene[], target?: Box2): Box2;
+    resetCameraByBoundingBox(box: IBox2, animate?: boolean): Promise<void>;
+    animateCamera(from: ICamera2Position, to: ICamera2Position): Promise<void>;
+    computeBoundingBox(scenes: Scene[], target?: Box2): Box2;
     expandScenesBoundingBox(scenes: Scene[], box?: Box2): void;
     /**
      * @see Application.running
      */
-    update(): void;
+    update(time?: DOMHighResTimeStamp): void;
 }
+export declare const CAMERA_SESSION_KEY = "camera_position_";

package/lib/environment.worker.js

@@ -11,6 +11,8 @@ var Pe = {
   fps: 60,
   syncDelay: 800,
   animateDuration: 600,
+  mergeRendering: !1,
+  // 合并渲染
   usedCache: !1,
   showPoints: !1,
   wireframe: !1,
@@ -3995,7 +3997,7 @@ Fu.__DOMHandler = Eu;
 Fu.normalizeLineEndings = Le;
 Fu.DOMParser = Ie;
 var gr = Fu.DOMParser;
-const Er = "1.0.36";
+const Er = "1.0.39";
 function vr() {
   return typeof window < "u" && ({}.toString.call(window) === "[object Window]" || {}.toString.call(window) === "[object global]");
 }
@@ -4432,7 +4434,7 @@ function Tr(u) {
 `, postMessage({ cmd: "echo", data: { msg: e } });
 }
 function Nr() {
-  console.log("- DOMParser: ", !!P.window.DOMParser);
+  console.log("- DOMParser: ", !!DOMParser, !!P.window.DOMParser);
   const u = new P.window.DOMParser().parseFromString(
     `<xml xmlns="a" xmlns:c="./lite">
 	<child>test</child>

package/lib/extras/adapter.d.ts

@@ -0,0 +1,62 @@
+import { default as EventDispatcher } from '../core/event-dispatcher';
+import { default as Box2 } from '../math/box2';
+import { IObject2, ITree } from '../interfaces';
+import { IApplicationConfig } from '../applications/application';
+export declare class Adapter extends EventDispatcher {
+    name: string;
+    params: IApplicationConfig;
+    boundingBox: Box2;
+    resources: Record<string, IObject2[]>;
+    _resourcesMap: Record<string, IObject2>;
+    _resourcesTree: ITree[];
+    private _svg?;
+    private _svgRoot?;
+    private _viewBox;
+    private _elementsMap;
+    constructor(config?: IApplicationConfig);
+    destroy(): void;
+    clear(): void;
+    load(url: string, layers?: string[]): Promise<void>;
+    init(str?: string): void;
+    /**
+     * background:
+     *    ...
+     *
+     * gros
+     * rm
+     *    ...
+     * gros-labels
+     * rm-labels
+     *    ...
+     */
+    initResources(): void;
+    initResourcesTree(): void;
+    initResource(id: string): void;
+    getResources(): IObject2[] | undefined;
+    getLayers(lv?: number): ITree[];
+    getElementById(id?: string): Element | undefined;
+    getSymbolElement(el?: Element): Element | undefined;
+    trans2Shape(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transG(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transSymbol(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transPath(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transUse(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transCircle(el?: Element, flipY?: boolean): IObject2 | undefined;
+    /**
+     * test linked to asset
+     * 1、old version: split with ';', use first；
+     * 2、new version: use 'aid' attribute；
+     * 3、use 'assetId' + SPLITTER + LABEL_TAG save to elementsMap;
+     */
+    transText(el?: Element, flipY?: boolean): IObject2 | undefined;
+    getAssetLabelId(assetId: string): string;
+    getResourceById(id?: string): IObject2 | undefined;
+    getResourceTreeById(t: ITree | ITree[], id?: string): ITree | undefined;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
+    _updateAllLayersVisibility(visible?: boolean): void;
+    _updateLayersVisibility(t: ITree, visible?: boolean): void;
+}
+export declare enum AdapterEnum {
+    INITIALIZATION_START = "INITIALIZATION_START",
+    INITIALIZATION_COMPLETE = "INITIALIZATION_COMPLETE"
+}

package/lib/extras/chef.d.ts

@@ -1,5 +1,5 @@
 import { IElement, ISvgElement } from '../svg/interfaces';
-import { IGroup2, IShape } from '../interfaces';
+import { IGroup2, IShape, ITree } from '../interfaces';
 import { default as Box2 } from '../math/box2';
 export declare class Chef {
     svg?: HTMLElement;
@@ -15,15 +15,9 @@ export declare class Chef {
     bind(data: ISvgElement): this;
     splitDefs(): this;
     splitLayers(ids?: string[], out?: (IGroup2 | IShape)[]): this;
-    getLayers(lv?: number): TLayer[];
-    _getLayer(el: IElement, lv?: number, lvi?: number, out?: TLayer[]): TLayer[];
+    getLayers(lv?: number): ITree[];
+    _getLayer(el: IElement, lv?: number, lvi?: number, out?: ITree[]): ITree[];
     getById(id: string): IGroup2 | IShape | undefined;
     getByIds(ids: string[]): (IGroup2 | IShape)[];
     trans2RenderObject(el: IElement): IGroup2 | IShape | undefined;
 }
-export type TLayer = {
-    id: string;
-    label: string;
-    selected?: boolean;
-    children?: TLayer[];
-};

package/lib/extras/interfaces.d.ts

@@ -52,6 +52,8 @@ export interface IApp {
     highlightDummies(ids: string | string[]): void;
     resetHighlightDummies(): void;
 }
+export interface IResource {
+}
 export declare enum AE_TYPES {
     DEFAULT = "default",
     INFO = "info",

package/lib/extras/svg-app.d.ts

@@ -1,6 +1,5 @@
 import { default as EventDispatcher } from '../core/event-dispatcher';
 import { IApplicationConfig } from '../applications/application';
-import { TLayer } from './chef';
 import { default as SvgRenderer } from '../renders/svg-renderer';
 import { IApp, IDummyVo } from './interfaces';
 import { default as Scene } from '../scenes/scene';
@@ -16,20 +15,6 @@ export interface ISvgAppConfig extends IApplicationConfig {
     selectEnable?: boolean;
     multiSelectEnable?: boolean;
     socialDistanceEnable?: boolean;
-    defaultFill?: string;
-    defaultStroke?: string;
-    infoFill?: string;
-    infoStroke?: string;
-    primaryFill?: string;
-    primaryStroke?: string;
-    successFill?: string;
-    successStroke?: string;
-    warningFill?: string;
-    warningStroke?: string;
-    dangerFill?: string;
-    dangerStroke?: string;
-    activeFill?: string;
-    activeStroke?: string;
 }
 export declare class SvgApp<Config extends ISvgAppConfig> extends EventDispatcher implements IApp {
     name: string;
@@ -59,9 +44,9 @@ export declare class SvgApp<Config extends ISvgAppConfig> extends EventDispatche
     start(): void;
     /** @description application's lifeCycle */
     running(time: DOMHighResTimeStamp): void;
-    load(url: string, layers?: string[], lv?: number, skeletons?: string[]): Promise<TLayer[]>;
+    load(url: string, layers?: string[], lv?: number, skeletons?: string[]): Promise<ITree[]>;
     setSkeletons(skeletons: string[]): void;
-    getLayers(lv?: number): TLayer[] | undefined;
+    getLayers(lv?: number): ITree[] | undefined;
     updateLayersVisibility(ids: string[], visible?: boolean): void;
     selectByIds(ids: string | string[]): void;
     getSelectedIds(): string[] | undefined;

package/lib/extras/svg-chef.d.ts

@@ -1,13 +1,12 @@
 import { ISvgElement } from '../svg/interfaces';
 import { default as Box2 } from '../math/box2';
 import { default as Vector2 } from '../math/vector2';
-import { TLayer } from './chef';
 import { ITree, IVector2 } from '../interfaces';
 export declare class SvgChef {
     svg?: HTMLElement;
     offset: Vector2;
     svgRoot?: Element;
-    layers: TLayer[];
+    layers: ITree[];
     elementsMap: Record<string, Element>;
     boundingBoxMap: Record<string, Box2>;
     boundingBox: Box2;
@@ -17,8 +16,8 @@ export declare class SvgChef {
     private readonly _exceptIds;
     private _lvi;
     bindSvg(data: HTMLElement): this;
-    getLayers(lv?: number): TLayer[];
-    _getSvgLayer(el: HTMLElement, lv?: number, lvi?: number, out?: TLayer[]): TLayer[];
+    getLayers(lv?: number): ITree[];
+    _getSvgLayer(el: HTMLElement, lv?: number, lvi?: number, out?: ITree[]): ITree[];
     getElementsMap(el: Element, out?: Record<string, Element>): Record<string, Element>;
     computeBoundingBoxMap(): Record<string, Box2>;
     updateLayersVisibility(ids: string[], visible?: boolean): void;
@@ -31,7 +30,7 @@ export declare class SvgChef {
     findSkeletonByPath(out?: Element[]): Element[];
     setTextInChildren2(o: Element, v: string): void;
     traverseSvg(o: Element, cb: Function): void;
-    traverseSvgTLayers(o: TLayer | TLayer[], cb: Function): void;
+    traverseSvgTLayers(o: ITree | ITree[], cb: Function): void;
     getLabelElementsByType(assetType: string, out?: Record<string, Element>): Record<string, Element>;
     getLabelElementById(id: string, assetType?: string): Element | undefined;
     setLabelsById(id: string, labels?: string[], assetType?: string): void;

package/lib/geometries/circle-geo2.d.ts

@@ -0,0 +1,14 @@
+import { Geo2, IGeo2Config } from './geo2';
+export interface ICircleGeo2 extends IGeo2Config {
+    radius?: number;
+    start?: number;
+    end?: number;
+}
+export declare class CircleGeo2<Config extends ICircleGeo2> extends Geo2<Config> {
+    readonly isCircle: boolean;
+    radius: number;
+    start: number;
+    end: number;
+    constructor(config?: Config);
+    recomputePath(): this;
+}