@wcardinal/wcardinal-ui 0.418.0 → 0.420.0

package/dist/types/wcardinal/ui/d-chart-axis-base-tick-container.d.ts

@@ -8,7 +8,7 @@ import { DChartAxisTickMinor } from "./d-chart-axis-tick-minor";
 import { DChartCoordinate } from "./d-chart-coordinate";
 import { DChartCoordinateTickMajorStepFunction } from "./d-chart-coordinate-tick-major-step-function";
 import { DChartCoordinateTickMinorStepFunction } from "./d-chart-coordinate-tick-minor-step-function";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 import { DChartRegion } from "./d-chart-region";
 import { EShape } from "./shape/e-shape";
 export interface DChartAxisBaseTickContainerOptions {
@@ -30,12 +30,12 @@ export declare class DChartAxisBaseTickContainer<CHART extends DBase = DBase, OP
     bind(container: DChartAxisContainer<CHART>, index: number): void;
     unbind(): void;
     update(): boolean;
-    protected getDomain(plotArea: DChartPlotArea<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
-    protected getDomainVisible(plotArea: DChartPlotArea<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
-    protected getRange(plotArea: DChartPlotArea<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
-    protected getRangeVisible(plotArea: DChartPlotArea<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
-    protected updateX(domainFrom: number, domainTo: number, domainVisibleFrom: number, domainVisibleTo: number, coordinate: DChartCoordinate<CHART>, majorShapes: EShape[], minorShapes: EShape[], gridlineShapes: EShape[], shapePositionY: number, transform: Matrix, plotAreaHeight: number): boolean;
-    protected updateY(rangeFrom: number, rangeTo: number, rangeVisibleFrom: number, rangeVisibleTo: number, coordinate: DChartCoordinate<CHART>, majorShapes: EShape[], minorShapes: EShape[], gridlineShapes: EShape[], shapePositionX: number, transform: Matrix, plotAreaWidth: number): boolean;
+    protected getDomain(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    protected getDomainVisible(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    protected getRange(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    protected getRangeVisible(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    protected updateX(domainFrom: number, domainTo: number, domainVisibleFrom: number, domainVisibleTo: number, coordinate: DChartCoordinate<CHART>, majorShapes: EShape[], minorShapes: EShape[], gridlineShapes: EShape[], shapePositionY: number, transform: Matrix, plotAreaY: number, plotAreaHeight: number): boolean;
+    protected updateY(rangeFrom: number, rangeTo: number, rangeVisibleFrom: number, rangeVisibleTo: number, coordinate: DChartCoordinate<CHART>, majorShapes: EShape[], minorShapes: EShape[], gridlineShapes: EShape[], shapePositionX: number, transform: Matrix, plotAreaX: number, plotAreaWidth: number): boolean;
     protected showMajor(shape: EShape, x: number, y: number, text?: string): void;
     protected showMajorGridline(shape: EShape, value: number, x: number, y: number, sx: number, sy: number): void;
     protected hideMajor(shape: EShape): void;

package/dist/types/wcardinal/ui/d-chart-axis-container-impl.d.ts

@@ -2,15 +2,15 @@ import { DBase } from "./d-base";
 import { DChartAxis } from "./d-chart-axis";
 import { DChartAxisContainer, DChartAxisContainerOptions } from "./d-chart-axis-container";
 import { DChartAxisPosition } from "./d-chart-axis-position";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 import { EShapeContainer } from "./shape/e-shape-container";
 export declare class DChartAxisContainerImpl<CHART extends DBase = DBase> implements DChartAxisContainer<CHART> {
-    protected _plotArea: DChartPlotArea<CHART>;
+    protected _plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
     protected _container: EShapeContainer;
     protected _list: Map<DChartAxisPosition, DChartAxis<CHART>[]>;
-    constructor(plotArea: DChartPlotArea<CHART>, options?: DChartAxisContainerOptions<CHART>);
+    constructor(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, container: EShapeContainer, options?: DChartAxisContainerOptions<CHART>);
     get container(): EShapeContainer;
-    get plotArea(): DChartPlotArea<CHART>;
+    get plotArea(): DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
     add(axis: DChartAxis<CHART>): void;
     get(position: DChartAxisPosition | keyof typeof DChartAxisPosition, index: number): DChartAxis<CHART> | null;
     indexOf(axis: DChartAxis<CHART>): number;

package/dist/types/wcardinal/ui/d-chart-axis-container.d.ts

@@ -1,14 +1,14 @@
 import { DBase } from "./d-base";
 import { DChartAxis } from "./d-chart-axis";
 import { DChartAxisPosition } from "./d-chart-axis-position";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 import { EShapeContainer } from "./shape/e-shape-container";
 export interface DChartAxisContainerOptions<CHART extends DBase = DBase> {
     list?: DChartAxis<CHART>[];
 }
 export interface DChartAxisContainer<CHART extends DBase = DBase> {
     readonly container: EShapeContainer;
-    readonly plotArea: DChartPlotArea<CHART>;
+    readonly plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
     add(axis: DChartAxis<CHART>): void;
     get(position: DChartAxisPosition | keyof typeof DChartAxisPosition, index: number): DChartAxis<CHART> | null;
     indexOf(axis: DChartAxis<CHART>): number;

package/dist/types/wcardinal/ui/d-chart-coordinate-base.d.ts

@@ -7,7 +7,7 @@ import { DChartCoordinateTickMajorStepFunction } from "./d-chart-coordinate-tick
 import { DChartCoordinateTickMinorStepFunction } from "./d-chart-coordinate-tick-minor-step-function";
 import { DChartCoordinateTransform, DChartCoordinateTransformOptions } from "./d-chart-coordinate-transform";
 import { DChartCoordinateTransformMark } from "./d-chart-coordinate-transform-mark";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 import { DChartRegion } from "./d-chart-region";
 import { DChartRegionImpl } from "./d-chart-region-impl";
 export declare abstract class DChartCoordinateBase<CHART extends DBase = DBase> implements DChartCoordinate<CHART> {
@@ -36,10 +36,10 @@ export declare abstract class DChartCoordinateBase<CHART extends DBase = DBase>
     mark(from?: number, to?: number): void;
     blend(ratio: number): void;
     protected doFit(from: number | undefined, to: number | undefined, result: DChartCoordinateTransformMark | DChartCoordinateTransform<CHART>): void;
-    protected getPixelDomain(plotArea: DChartPlotArea<CHART>, result: DChartRegion): DChartRegion;
-    protected getPixelRange(plotArea: DChartPlotArea<CHART>, result: DChartRegion): DChartRegion;
-    protected toFitDomain(from: number | undefined, to: number | undefined, plotArea: DChartPlotArea<CHART>, result: DChartRegion): DChartRegion;
-    protected toFitRange(from: number | undefined, to: number | undefined, plotArea: DChartPlotArea<CHART>, result: DChartRegion): DChartRegion;
+    protected getPixelDomain(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, result: DChartRegion): DChartRegion;
+    protected getPixelRange(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, result: DChartRegion): DChartRegion;
+    protected toFitDomain(from: number | undefined, to: number | undefined, plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, result: DChartRegion): DChartRegion;
+    protected toFitRange(from: number | undefined, to: number | undefined, plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, result: DChartRegion): DChartRegion;
     protected doFit_(pixelFrom: number, pixelTo: number, region: DChartRegion, result: DChartCoordinateTransformMark | DChartCoordinateTransform<CHART>): void;
     get id(): number;
     get transform(): DChartCoordinateTransform<CHART>;

package/dist/types/wcardinal/ui/d-chart-coordinate-container-impl.d.ts

@@ -1,15 +1,15 @@
 import { DBase } from "./d-base";
 import { DChartCoordinateContainer, DChartCoordinateContainerOptions } from "./d-chart-coordinate-container";
 import { DChartCoordinateContainerSub } from "./d-chart-coordinate-container-sub";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 export declare class DChartCoordinateContainerImpl<CHART extends DBase = DBase> implements DChartCoordinateContainer<CHART> {
     protected _x: DChartCoordinateContainerSub<CHART>;
     protected _y: DChartCoordinateContainerSub<CHART>;
-    protected _plotArea: DChartPlotArea<CHART>;
-    constructor(plotArea: DChartPlotArea<CHART>, options?: DChartCoordinateContainerOptions<CHART>);
+    protected _plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
+    constructor(plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>, options?: DChartCoordinateContainerOptions<CHART>);
     get x(): DChartCoordinateContainerSub<CHART>;
     get y(): DChartCoordinateContainerSub<CHART>;
-    get plotArea(): DChartPlotArea<CHART>;
+    get plotArea(): DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
     fit(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
     mark(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
     blend(ratio: number): this;

package/dist/types/wcardinal/ui/d-chart-coordinate-container.d.ts

@@ -1,7 +1,7 @@
 import { DBase } from "./d-base";
 import { DChartCoordinate } from "./d-chart-coordinate";
 import { DChartCoordinateContainerSub } from "./d-chart-coordinate-container-sub";
-import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
 export interface DChartCoordinateContainerOptions<CHART extends DBase = DBase> {
     x?: DChartCoordinate<CHART> | DChartCoordinate<CHART>[];
     y?: DChartCoordinate<CHART> | DChartCoordinate<CHART>[];
@@ -9,7 +9,7 @@ export interface DChartCoordinateContainerOptions<CHART extends DBase = DBase> {
 export interface DChartCoordinateContainer<CHART extends DBase = DBase> {
     x: DChartCoordinateContainerSub<CHART>;
     y: DChartCoordinateContainerSub<CHART>;
-    plotArea: DChartPlotArea<CHART>;
+    plotArea: DChartPlotArea<CHART> | DChartPlotAreaLike<CHART>;
     fit(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
     mark(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
     blend(ratio: number): this;

package/dist/types/wcardinal/ui/{d-chart-plot-area-impl.d.ts → d-chart-plot-area-base.d.ts}

@@ -2,48 +2,51 @@ import { InteractionEvent, InteractionManager, Point, Rectangle, Renderer } from
 import { DBase } from "./d-base";
 import { DBaseOverflowMask } from "./d-base-overflow-mask";
 import { DChartAxisContainer } from "./d-chart-axis-container";
-import { DChartAxisContainerImpl } from "./d-chart-axis-container-impl";
 import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
 import { DChartPlotArea, DThemeChartPlotArea, DChartPlotAreaOptions } from "./d-chart-plot-area";
 import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
 import { DChartSeriesContainer } from "./d-chart-series-container";
-import { DChartSeriesContainerImpl } from "./d-chart-series-container-impl";
 import { DView } from "./d-view";
 import { DViewImpl } from "./d-view-impl";
 import { UtilWheelEventDeltas } from "./util/util-wheel-event";
-export declare class DChartPlotAreaImpl<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea, OPTIONS extends DChartPlotAreaOptions<CHART, THEME> = DChartPlotAreaOptions<CHART, THEME>> extends DBase<THEME, OPTIONS> implements DChartPlotArea<CHART> {
+import { DChartRegion } from "./d-chart-region";
+import { DChartAxisPosition } from "./d-chart-axis-position";
+export declare abstract class DChartPlotAreaBase<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea, OPTIONS extends DChartPlotAreaOptions<CHART, THEME> = DChartPlotAreaOptions<CHART, THEME>> extends DBase<THEME, OPTIONS> implements DChartPlotArea<CHART> {
+    protected _isContainerBoundsDirty: boolean;
+    protected _containerBounds: Rectangle;
+    protected _workPoint: Point;
+    protected _pixelBounds: Rectangle;
     protected _chart: CHART;
-    protected _container: DChartPlotAreaContainer;
-    protected _series: DChartSeriesContainerImpl<CHART>;
-    protected _coordinate: DChartCoordinateContainer<CHART>;
-    protected _axis: DChartAxisContainerImpl<CHART>;
     protected _view: DViewImpl;
     protected _isViewDirty: boolean;
-    protected _isBoundsInContainerDirty: boolean;
-    protected _boundsInContainer: Rectangle;
     protected _overflowMask?: DBaseOverflowMask | null;
-    protected _workPoint: Point;
     protected _blendStartTime: number;
     protected _blendDuration: number;
     protected _blendTimeout: number | null;
     protected _onBlendBound: () => void;
     constructor(chart: CHART, options?: OPTIONS);
-    protected init(options?: OPTIONS): void;
     onResize(newWidth: number, newHeight: number, oldWidth: number, oldHeight: number): void;
-    protected getOverflowMask(): DBaseOverflowMask;
     get chart(): CHART;
-    get coordinate(): DChartCoordinateContainer<CHART>;
-    get series(): DChartSeriesContainer<CHART>;
-    get container(): DChartPlotAreaContainer;
-    get axis(): DChartAxisContainer<CHART>;
+    abstract get coordinate(): DChartCoordinateContainer<CHART>;
+    abstract get series(): DChartSeriesContainer<CHART>;
+    abstract get container(): DChartPlotAreaContainer;
+    abstract get axis(): DChartAxisContainer<CHART>;
     get view(): DView;
+    abstract newView(options?: OPTIONS): DViewImpl;
     protected onWheel(e: WheelEvent, deltas: UtilWheelEventDeltas, global: Point): boolean;
     protected onDblClick(e: MouseEvent | TouchEvent, interactionManager: InteractionManager): boolean;
     protected onDown(e: InteractionEvent): void;
     render(renderer: Renderer): void;
-    destroy(): void;
+    protected abstract onViewDirty(): void;
+    abstract destroy(): void;
+    getPixelDomain(result: DChartRegion): DChartRegion;
+    getPixelRange(result: DChartRegion): DChartRegion;
+    getPixelBounds(): Rectangle;
+    getAxisBounds(position: DChartAxisPosition): Rectangle;
+    getSelectionBoundsX(): Rectangle;
+    getSelectionBoundsY(): Rectangle;
+    getContainerBounds(): Rectangle;
+    abstract fit(duration?: number, domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
+    protected abstract onBlend(): void;
     protected getType(): string;
-    getBoundsInContainer(): Rectangle;
-    fit(duration?: number, domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
-    protected onBlend(): void;
 }

package/dist/types/wcardinal/ui/d-chart-plot-area-onefold.d.ts

@@ -0,0 +1,41 @@
+import { DBase } from "./d-base";
+import { DThemeChartPlotArea, DChartPlotAreaOptions } from "./d-chart-plot-area";
+import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
+import { DChartPlotAreaBase } from "./d-chart-plot-area-base";
+import { DBaseOverflowMask } from "./d-base-overflow-mask";
+import { DChartSeriesContainer, DChartSeriesContainerOptions } from "./d-chart-series-container";
+import { DChartSeriesContainerImpl } from "./d-chart-series-container-impl";
+import { DChartCoordinateContainer, DChartCoordinateContainerOptions } from "./d-chart-coordinate-container";
+import { DChartAxisContainer, DChartAxisContainerOptions } from "./d-chart-axis-container";
+import { DChartAxisContainerImpl } from "./d-chart-axis-container-impl";
+import { DChartSelection } from "./d-chart-selection";
+import { DChartSeries } from "./d-chart-series";
+import { DChartAxis } from "./d-chart-axis";
+import { DViewImpl } from "./d-view-impl";
+export interface DChartPlotAreaSingleSeriesContainerOptions<CHART extends DBase = DBase> extends DChartSeriesContainerOptions<CHART> {
+    selection?: DChartSelection<CHART>;
+}
+export interface DChartPlotAreaSingleOptions<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea> extends DChartPlotAreaOptions<CHART, THEME> {
+    series?: DChartPlotAreaSingleSeriesContainerOptions<CHART>;
+    coordinate?: DChartCoordinateContainerOptions<CHART>;
+    axis?: DChartAxisContainerOptions<CHART>;
+}
+export declare class DChartPlotAreaOnefold<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea, OPTIONS extends DChartPlotAreaSingleOptions<CHART, THEME> = DChartPlotAreaSingleOptions<CHART, THEME>> extends DChartPlotAreaBase<CHART, THEME, OPTIONS> {
+    protected _container: DChartPlotAreaContainer;
+    protected _series: DChartSeriesContainerImpl<CHART>;
+    protected _coordinate: DChartCoordinateContainer<CHART>;
+    protected _axis: DChartAxisContainerImpl<CHART>;
+    constructor(chart: CHART, options?: OPTIONS);
+    protected getOverflowMask(): DBaseOverflowMask;
+    protected addSeries(series: DChartSeriesContainer<CHART>, list?: DChartSeries<CHART>[]): void;
+    protected addAxes(axis: DChartAxisContainer<CHART>, list?: DChartAxis<CHART>[]): void;
+    get coordinate(): DChartCoordinateContainer<CHART>;
+    get series(): DChartSeriesContainer<CHART>;
+    get container(): DChartPlotAreaContainer;
+    get axis(): DChartAxisContainer<CHART>;
+    newView(options?: OPTIONS): DViewImpl;
+    protected onViewDirty(): void;
+    fit(duration?: number, domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
+    protected onBlend(): void;
+    destroy(): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-axis-container.d.ts

@@ -0,0 +1,24 @@
+import { DBase } from "./d-base";
+import { DChartAxis } from "./d-chart-axis";
+import { DChartAxisContainer } from "./d-chart-axis-container";
+import { DChartAxisPosition } from "./d-chart-axis-position";
+import { DChartPlotArea } from "./d-chart-plot-area";
+import { EShapeContainer } from "./shape/e-shape-container";
+export declare class DChartPlotAreaTwofoldAxisContainer<CHART extends DBase = DBase> implements DChartAxisContainer<CHART> {
+    protected _plotArea: DChartPlotArea<CHART>;
+    protected _container: EShapeContainer;
+    protected _list: Map<DChartAxisPosition, DChartAxis<CHART>[]>;
+    protected _primary: DChartAxisContainer<CHART>;
+    protected _secondary: DChartAxisContainer<CHART>;
+    constructor(plotArea: DChartPlotArea<CHART>, container: EShapeContainer, primary: DChartAxisContainer<CHART>, secondary: DChartAxisContainer<CHART>);
+    get container(): EShapeContainer;
+    get plotArea(): DChartPlotArea<CHART>;
+    add(axis: DChartAxis<CHART>): void;
+    get(position: DChartAxisPosition | keyof typeof DChartAxisPosition, index: number): DChartAxis<CHART> | null;
+    indexOf(axis: DChartAxis<CHART>): number;
+    clear(position: DChartAxisPosition | keyof typeof DChartAxisPosition): this;
+    size(position: DChartAxisPosition | keyof typeof DChartAxisPosition): number;
+    update(): void;
+    onRender(): void;
+    destroy(): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-coordinate-container-sub.d.ts

@@ -0,0 +1,22 @@
+import { DBase } from "./d-base";
+import { DChartCoordinate } from "./d-chart-coordinate";
+import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
+import { DChartCoordinateContainerSub } from "./d-chart-coordinate-container-sub";
+export declare class DChartPlotAreaTwofoldCoorinateContainerSub<CHART extends DBase = DBase> implements DChartCoordinateContainerSub<CHART> {
+    protected _container: DChartCoordinateContainer<CHART>;
+    protected _primary: DChartCoordinateContainerSub<CHART>;
+    protected _secondary: DChartCoordinateContainerSub<CHART>;
+    constructor(container: DChartCoordinateContainer<CHART>, primary: DChartCoordinateContainerSub<CHART>, secondary: DChartCoordinateContainerSub<CHART>);
+    get container(): DChartCoordinateContainer<CHART>;
+    add(coordinate: DChartCoordinate<CHART>, index?: number): this;
+    get(index: number): DChartCoordinate<CHART> | null;
+    indexOf(coordinate: DChartCoordinate<CHART>): number;
+    remove(coordinate: DChartCoordinate<CHART>): DChartCoordinate<CHART> | null;
+    remove(index: number): DChartCoordinate<CHART> | null;
+    clear(): this;
+    destroy(): this;
+    size(): number;
+    fit(from?: number, to?: number): this;
+    mark(from?: number, to?: number): this;
+    blend(ratio: number): this;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-coordinate-container.d.ts

@@ -0,0 +1,18 @@
+import { DBase } from "./d-base";
+import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
+import { DChartCoordinateContainerSub } from "./d-chart-coordinate-container-sub";
+import { DChartPlotArea } from "./d-chart-plot-area";
+export declare class DChartPlotAreaTwofoldCoorinateContainer<CHART extends DBase = DBase> implements DChartCoordinateContainer<CHART> {
+    protected _x: DChartCoordinateContainerSub<CHART>;
+    protected _y: DChartCoordinateContainerSub<CHART>;
+    protected _plotArea: DChartPlotArea<CHART>;
+    protected _primary: DChartCoordinateContainer<CHART>;
+    protected _secondary: DChartCoordinateContainer<CHART>;
+    constructor(plotArea: DChartPlotArea<CHART>, primary: DChartCoordinateContainer<CHART>, secondary: DChartCoordinateContainer<CHART>);
+    get x(): DChartCoordinateContainerSub<CHART>;
+    get y(): DChartCoordinateContainerSub<CHART>;
+    get plotArea(): DChartPlotArea<CHART>;
+    fit(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
+    mark(domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
+    blend(ratio: number): this;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-overflow-mask-primary.d.ts

@@ -0,0 +1,5 @@
+import { DBase } from "./d-base";
+import { DBaseOverflowMaskSimple } from "./d-base-overflow-mask-simple";
+export declare class DChartPlotAreaTwofoldOverflowMaskPrimary extends DBaseOverflowMaskSimple {
+    onReflow(base: DBase, width: number, height: number): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-overflow-mask-secondary.d.ts

@@ -0,0 +1,5 @@
+import { DBase } from "./d-base";
+import { DBaseOverflowMaskSimple } from "./d-base-overflow-mask-simple";
+export declare class DChartPlotAreaTwofoldOverflowMaskSecondary extends DBaseOverflowMaskSimple {
+    onReflow(base: DBase, width: number, height: number): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-series-container.d.ts

@@ -0,0 +1,43 @@
+import { DBase } from "./d-base";
+import { DChartCoordinate } from "./d-chart-coordinate";
+import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartRegion } from "./d-chart-region";
+import { DChartRegionImpl } from "./d-chart-region-impl";
+import { DChartSelection } from "./d-chart-selection";
+import { DChartSeries, DChartSeriesHitResult } from "./d-chart-series";
+import { DChartSeriesContainer } from "./d-chart-series-container";
+import { DChartSeriesContainerImpl } from "./d-chart-series-container-impl";
+import { DChartSeriesFillComputed, DChartSeriesFillComputedOptions } from "./d-chart-series-fill-computed";
+import { DChartSeriesPaddingComputed, DChartSeriesPaddingComputedOptions } from "./d-chart-series-padding-computed";
+import { DChartSeriesPointComputed, DChartSeriesPointComputedOptions } from "./d-chart-series-point-computed";
+import { DChartSeriesStrokeComputed, DChartSeriesStrokeComputedOptions } from "./d-chart-series-stroke-computed";
+export declare class DChartPlotAreaTwofoldSeriesContainer<CHART extends DBase = DBase> implements DChartSeriesContainer<CHART> {
+    protected static WORK_CALCHITPOINT: DChartSeriesHitResult | undefined;
+    protected _plotArea: DChartPlotArea<CHART>;
+    protected _primary: DChartSeriesContainerImpl<CHART>;
+    protected _secondary: DChartSeriesContainerImpl<CHART>;
+    protected _domain: DChartRegionImpl;
+    protected _range: DChartRegionImpl;
+    constructor(plotArea: DChartPlotArea<CHART>, primary: DChartSeriesContainerImpl<CHART>, secondary: DChartSeriesContainerImpl<CHART>);
+    newFill(index: number, options: DChartSeriesFillComputedOptions | undefined): DChartSeriesFillComputed;
+    newStroke(index: number, options: DChartSeriesStrokeComputedOptions | undefined): DChartSeriesStrokeComputed;
+    newSize(index: number, options: DChartSeriesPointComputedOptions | undefined, x: number, y: number): DChartSeriesPointComputed;
+    newOffset(index: number, options: DChartSeriesPointComputedOptions | undefined, x: number, y: number): DChartSeriesPointComputed;
+    newPadding(index: number, options: DChartSeriesPaddingComputedOptions | undefined): DChartSeriesPaddingComputed;
+    get plotArea(): DChartPlotArea<CHART>;
+    get selection(): DChartSelection<CHART> | null;
+    update(): void;
+    onRender(): void;
+    add(series: DChartSeries<CHART>): void;
+    get(index: number): DChartSeries<CHART> | null;
+    indexOf(series: DChartSeries<CHART>): number;
+    clear(): this;
+    size(): number;
+    destroy(): void;
+    getDomain(coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    getRange(coordinate: DChartCoordinate<CHART>, result: DChartRegion): DChartRegion;
+    get domain(): DChartRegion;
+    get range(): DChartRegion;
+    hitTest(x: number, y: number): DChartSeries<CHART> | null;
+    calcHitPoint(x: number, y: number, result: DChartSeriesHitResult): DChartSeries<CHART> | null;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-sub-base.d.ts

@@ -0,0 +1,46 @@
+import { DBase } from "./d-base";
+import { DChartPlotArea } from "./d-chart-plot-area";
+import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
+import { DBaseOverflowMaskSimple } from "./d-base-overflow-mask-simple";
+import { DChartSeriesContainerImpl } from "./d-chart-series-container-impl";
+import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
+import { DChartAxisContainer } from "./d-chart-axis-container";
+import { DChartAxisContainerImpl } from "./d-chart-axis-container-impl";
+import { DChartPlotAreaTwofoldSub, DChartPlotAreaTwofoldSubOptions } from "./d-chart-plot-area-twofold-sub";
+import { Point, Rectangle } from "pixi.js";
+import { DChartRegion } from "./d-chart-region";
+import { DChartAxisPosition } from "./d-chart-axis-position";
+import { EShapeContainer } from "./shape/e-shape-container";
+export interface DChartPlotAreaTwofoldSubParent<CHART extends DBase = DBase> extends DChartPlotArea<CHART> {
+}
+export declare abstract class DChartPlotAreaTwofoldSubBase<CHART extends DBase = DBase> implements DChartPlotAreaTwofoldSub<CHART> {
+    protected _isContainerBoundsDirty: boolean;
+    protected _containerBounds: Rectangle;
+    protected _workPoint: Point;
+    protected _plotArea: DChartPlotAreaTwofoldSubParent<CHART>;
+    protected _container: DChartPlotAreaContainer;
+    protected _series: DChartSeriesContainerImpl<CHART>;
+    protected _coordinate: DChartCoordinateContainer<CHART>;
+    protected _axis: DChartAxisContainerImpl<CHART>;
+    protected _overflowMask?: DBaseOverflowMaskSimple;
+    protected _margin: number;
+    constructor(plotArea: DChartPlotAreaTwofoldSubParent<CHART>, onContainerChange: () => void, mask: boolean, margin: number, axisShapeContainer: EShapeContainer, options?: DChartPlotAreaTwofoldSubOptions<CHART>);
+    protected abstract getOverflowMask(): DBaseOverflowMaskSimple;
+    get plotArea(): DChartPlotArea<CHART>;
+    get chart(): CHART;
+    get container(): DChartPlotAreaContainer;
+    get series(): DChartSeriesContainerImpl<CHART>;
+    get coordinate(): DChartCoordinateContainer<CHART>;
+    get axis(): DChartAxisContainer<CHART>;
+    on(name: string, callback: Function, context?: any): this;
+    off(name: string, callback?: Function, context?: any): this;
+    getPixelDomain(result: DChartRegion): DChartRegion;
+    abstract getPixelRange(result: DChartRegion): DChartRegion;
+    abstract getPixelBounds(): Rectangle;
+    getAxisBounds(position: DChartAxisPosition): Rectangle;
+    getSelectionBoundsX(): Rectangle;
+    getSelectionBoundsY(): Rectangle;
+    toBoundsDirty(): void;
+    abstract getContainerBounds(): PIXI.Rectangle;
+    destroy(): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-sub-primary.d.ts

@@ -0,0 +1,11 @@
+import { Rectangle } from "pixi.js";
+import { DBase } from "./d-base";
+import { DBaseOverflowMaskSimple } from "./d-base-overflow-mask-simple";
+import { DChartPlotAreaTwofoldSubBase } from "./d-chart-plot-area-twofold-sub-base";
+import { DChartRegion } from "./d-chart-region";
+export declare class DChartPlotAreaTwofoldSubPrimary<CHART extends DBase = DBase> extends DChartPlotAreaTwofoldSubBase<CHART> {
+    protected getOverflowMask(): DBaseOverflowMaskSimple;
+    getPixelRange(result: DChartRegion): DChartRegion;
+    getPixelBounds(): Rectangle;
+    getContainerBounds(): PIXI.Rectangle;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-sub-secondary.d.ts

@@ -0,0 +1,11 @@
+import { Rectangle } from "pixi.js";
+import { DBase } from "./d-base";
+import { DBaseOverflowMaskSimple } from "./d-base-overflow-mask-simple";
+import { DChartPlotAreaTwofoldSubBase } from "./d-chart-plot-area-twofold-sub-base";
+import { DChartRegion } from "./d-chart-region";
+export declare class DChartPlotAreaTwofoldSubSecondary<CHART extends DBase = DBase> extends DChartPlotAreaTwofoldSubBase<CHART> {
+    protected getOverflowMask(): DBaseOverflowMaskSimple;
+    getPixelRange(result: DChartRegion): DChartRegion;
+    getPixelBounds(): Rectangle;
+    getContainerBounds(): PIXI.Rectangle;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-sub.d.ts

@@ -0,0 +1,22 @@
+import { DBase } from "./d-base";
+import { DChartPlotArea, DChartPlotAreaLike } from "./d-chart-plot-area";
+import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
+import { DChartSeriesContainerOptions } from "./d-chart-series-container";
+import { DChartSeriesContainerImpl } from "./d-chart-series-container-impl";
+import { DChartCoordinateContainer, DChartCoordinateContainerOptions } from "./d-chart-coordinate-container";
+import { DChartAxisContainer, DChartAxisContainerOptions } from "./d-chart-axis-container";
+export interface DChartPlotAreaTwofoldSubOptions<CHART extends DBase = DBase> {
+    series?: DChartSeriesContainerOptions<CHART>;
+    coordinate?: DChartCoordinateContainerOptions<CHART>;
+    axis?: DChartAxisContainerOptions<CHART>;
+}
+export interface DChartPlotAreaTwofoldSub<CHART extends DBase = DBase> extends DChartPlotAreaLike<CHART> {
+    readonly plotArea: DChartPlotArea<CHART>;
+    readonly chart: CHART;
+    readonly container: DChartPlotAreaContainer;
+    readonly series: DChartSeriesContainerImpl<CHART>;
+    readonly coordinate: DChartCoordinateContainer<CHART>;
+    readonly axis: DChartAxisContainer<CHART>;
+    getContainerBounds(): PIXI.Rectangle;
+    destroy(): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold-view-target.d.ts

@@ -0,0 +1,30 @@
+import { IPoint, Rectangle } from "pixi.js";
+import { DBase } from "./d-base";
+import { DChartPlotAreaTwofoldSubPrimary } from "./d-chart-plot-area-twofold-sub-primary";
+import { DChartPlotAreaTwofoldSubSecondary } from "./d-chart-plot-area-twofold-sub-secondary";
+import { DViewTarget, DViewTargetPoint } from "./d-view-to-target";
+import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
+export interface DChartPlotAreaTwofoldViewTargetParent<CHART extends DBase> {
+    readonly primary: DChartPlotAreaTwofoldSubPrimary<CHART>;
+    readonly secondary: DChartPlotAreaTwofoldSubSecondary<CHART>;
+}
+export declare class DChartPlotAreaTwofoldViewTargetPoint {
+    protected _primary: IPoint;
+    protected _secondary: IPoint;
+    constructor(primary: IPoint, secondary: IPoint);
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    set(x?: number, y?: number): this;
+}
+export declare class DChartPlotAreaTwofoldViewTarget<CHART extends DBase> implements DViewTarget {
+    protected _primary: DChartPlotAreaContainer;
+    protected _secondary: DChartPlotAreaContainer;
+    protected _scale: DChartPlotAreaTwofoldViewTargetPoint;
+    protected _position: DChartPlotAreaTwofoldViewTargetPoint;
+    constructor(primary: DChartPlotAreaContainer, secondary: DChartPlotAreaContainer);
+    get scale(): DViewTargetPoint;
+    get position(): DViewTargetPoint;
+    getLocalBounds(rect: Rectangle): Rectangle;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area-twofold.d.ts

@@ -0,0 +1,46 @@
+import { DBase } from "./d-base";
+import { DThemeChartPlotArea, DChartPlotAreaOptions } from "./d-chart-plot-area";
+import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
+import { DChartPlotAreaBase } from "./d-chart-plot-area-base";
+import { DChartSeriesContainer } from "./d-chart-series-container";
+import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
+import { DChartAxisContainer, DChartAxisContainerOptions } from "./d-chart-axis-container";
+import { DChartPlotAreaTwofoldSeriesContainer } from "./d-chart-plot-area-twofold-series-container";
+import { DChartPlotAreaTwofoldAxisContainer } from "./d-chart-plot-area-twofold-axis-container";
+import { DChartSelection } from "./d-chart-selection";
+import { DChartPlotAreaTwofoldSubOptions } from "./d-chart-plot-area-twofold-sub";
+import { DChartPlotAreaTwofoldSubPrimary } from "./d-chart-plot-area-twofold-sub-primary";
+import { DChartPlotAreaTwofoldSubSecondary } from "./d-chart-plot-area-twofold-sub-secondary";
+import { DChartSeries } from "./d-chart-series";
+import { DChartAxis } from "./d-chart-axis";
+import { DViewImpl } from "./d-view-impl";
+export interface DChartPlotAreaTwofoldOptions<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea> extends DChartPlotAreaOptions<CHART, THEME> {
+    primary?: DChartPlotAreaTwofoldSubOptions<CHART>;
+    secondary?: DChartPlotAreaTwofoldSubOptions<CHART>;
+    selection?: DChartSelection<CHART>;
+    axis?: DChartAxisContainerOptions<CHART>;
+    margin?: number;
+}
+export declare class DChartPlotAreaTwofold<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea, OPTIONS extends DChartPlotAreaTwofoldOptions<CHART, THEME> = DChartPlotAreaTwofoldOptions<CHART, THEME>> extends DChartPlotAreaBase<CHART, THEME, OPTIONS> {
+    protected _primary: DChartPlotAreaTwofoldSubPrimary<CHART>;
+    protected _secondary: DChartPlotAreaTwofoldSubSecondary<CHART>;
+    protected _margin: number;
+    protected _coordinate: DChartCoordinateContainer<CHART>;
+    protected _series: DChartPlotAreaTwofoldSeriesContainer<CHART>;
+    protected _axis: DChartPlotAreaTwofoldAxisContainer<CHART>;
+    constructor(chart: CHART, options?: OPTIONS);
+    protected addSeries(series: DChartSeriesContainer<CHART>, list?: DChartSeries<CHART>[]): void;
+    protected addAxes(axis: DChartAxisContainer<CHART>, list?: DChartAxis<CHART>[]): void;
+    get primary(): DChartPlotAreaTwofoldSubPrimary<CHART>;
+    get secondary(): DChartPlotAreaTwofoldSubSecondary<CHART>;
+    get container(): DChartPlotAreaContainer;
+    protected onContainerChange(): void;
+    get coordinate(): DChartCoordinateContainer<CHART>;
+    get series(): DChartSeriesContainer<CHART>;
+    get axis(): DChartAxisContainer<CHART>;
+    newView(options?: OPTIONS): DViewImpl;
+    protected onViewDirty(): void;
+    fit(duration?: number, domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
+    protected onBlend(): void;
+    destroy(): void;
+}

package/dist/types/wcardinal/ui/d-chart-plot-area.d.ts

@@ -1,19 +1,37 @@
 import { DBase, DBaseOptions, DThemeBase } from "./d-base";
-import { DChartSeriesContainer, DChartSeriesContainerOptions } from "./d-chart-series-container";
-import { DChartCoordinateContainer, DChartCoordinateContainerOptions } from "./d-chart-coordinate-container";
+import { DChartSeriesContainer } from "./d-chart-series-container";
+import { DChartCoordinateContainer } from "./d-chart-coordinate-container";
 import { DChartPlotAreaContainer } from "./d-chart-plot-area-container";
-import { DChartAxisContainer, DChartAxisContainerOptions } from "./d-chart-axis-container";
+import { DChartAxisContainer } from "./d-chart-axis-container";
 import { Rectangle } from "pixi.js";
 import { DView, DViewOptions } from "./d-view";
+import { DApplicationTarget } from "./d-application-like";
+import { DChartRegion } from "./d-chart-region";
+import { DChartAxisPosition } from "./d-chart-axis-position";
 export interface DChartPlotAreaOptions<CHART extends DBase = DBase, THEME extends DThemeChartPlotArea = DThemeChartPlotArea> extends DBaseOptions<THEME> {
     mask?: boolean;
-    coordinate?: DChartCoordinateContainerOptions<CHART>;
-    series?: DChartSeriesContainerOptions<CHART>;
-    axis?: DChartAxisContainerOptions<CHART>;
     view?: DViewOptions;
 }
 export interface DThemeChartPlotArea extends DThemeBase {
     isOverflowMaskEnabled(): boolean;
+    getMargin(): number;
+}
+export interface DChartPlotAreaLike<CHART extends DBase = DBase> extends DApplicationTarget {
+    readonly chart: CHART;
+    readonly plotArea: DChartPlotArea<CHART>;
+    readonly coordinate: DChartCoordinateContainer<CHART>;
+    readonly series: DChartSeriesContainer<CHART>;
+    readonly container: DChartPlotAreaContainer;
+    readonly axis: DChartAxisContainer<CHART>;
+    on(name: string, callback: Function, context?: any): this;
+    off(name: string, callback?: Function, context?: any): this;
+    getPixelDomain(result: DChartRegion): DChartRegion;
+    getPixelRange(result: DChartRegion): DChartRegion;
+    getPixelBounds(): Rectangle;
+    getAxisBounds(position: DChartAxisPosition): Rectangle;
+    getSelectionBoundsX(): Rectangle;
+    getSelectionBoundsY(): Rectangle;
+    getContainerBounds(): Rectangle;
 }
 export interface DChartPlotArea<CHART extends DBase = DBase> extends DBase {
     readonly chart: CHART;
@@ -23,5 +41,11 @@ export interface DChartPlotArea<CHART extends DBase = DBase> extends DBase {
     readonly axis: DChartAxisContainer<CHART>;
     readonly view: DView;
     fit(duration?: number, domainFrom?: number, domainTo?: number, rangeFrom?: number, rangeTo?: number): this;
-    getBoundsInContainer(): Rectangle;
+    getPixelDomain(result: DChartRegion): DChartRegion;
+    getPixelRange(result: DChartRegion): DChartRegion;
+    getPixelBounds(): Rectangle;
+    getAxisBounds(position: DChartAxisPosition): Rectangle;
+    getSelectionBoundsX(): Rectangle;
+    getSelectionBoundsY(): Rectangle;
+    getContainerBounds(): Rectangle;
 }

package/dist/types/wcardinal/ui/d-chart-selection-gridline-x.d.ts

@@ -4,6 +4,5 @@ import { DChartSelectionShapeBase } from "./d-chart-selection-shape-base";
 import { DChartSeriesContainer } from "./d-chart-series-container";
 export declare class DChartSelectionGridlineX<CHART extends DBase = DBase> extends DChartSelectionShapeBase<CHART> {
     update(container: DChartSeriesContainer<CHART>, position: IPoint, mappedPosition: IPoint): boolean;
-    protected isVisible(container: DChartSeriesContainer<CHART>, position: IPoint, mappedPosition: IPoint): boolean;
     protected getType(): string;
 }