@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/_shared/core/contract/sankey-contract.d.ts

@@ -0,0 +1,189 @@
+import type { HeatmapAnimationType, HeatmapEasing, HeatmapEngineMode, HeatmapEngineTier, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export interface SankeyNodeObject {
+    id: string;
+    label?: string;
+    color?: string;
+    column?: number;
+}
+export type SankeyNodeInput = SankeyNodeObject | string;
+export interface SankeyLinkObject {
+    source: string;
+    target: string;
+    value: number;
+    color?: string;
+}
+export type SankeyLinkTuple = readonly [
+    source: string,
+    target: string,
+    value: number
+];
+export type SankeyLinkInput = SankeyLinkObject | SankeyLinkTuple;
+export interface SankeyGraphInput {
+    nodes?: ReadonlyArray<SankeyNodeInput>;
+    links: ReadonlyArray<SankeyLinkInput>;
+}
+export type SankeyData = SankeyGraphInput | ReadonlyArray<SankeyLinkInput>;
+export type SankeyAlign = 'left' | 'right' | 'center' | 'justify';
+export type SankeyLinkColorMode = 'source' | 'target' | 'gradient';
+export type SankeyLabelMode = 'auto' | 'show' | 'hide';
+export interface SankeyNodeLabel {
+    index: number;
+    text: string;
+    x: number;
+    y: number;
+    side: 'left' | 'right';
+    maxWidth?: number;
+    shown: boolean;
+    hiddenBy?: 'overlap' | 'mode' | 'viewport';
+}
+export interface SankeyNode {
+    index: number;
+    id: string;
+    label: string;
+    column: number;
+    row: number;
+    value: number;
+    inValue: number;
+    outValue: number;
+    color: string | null;
+    sourceLinks: number[];
+    targetLinks: number[];
+    declared: boolean;
+    origin: 'data' | 'stream';
+}
+export interface SankeyLink {
+    index: number;
+    source: number;
+    target: number;
+    sourceId: string;
+    targetId: string;
+    value: number;
+    color: string | null;
+    origin: 'data' | 'stream';
+    backward: boolean;
+}
+export interface SankeyGraph {
+    nodes: SankeyNode[];
+    links: SankeyLink[];
+    columns: number;
+    dropped: number;
+    cycles: number;
+}
+export interface SankeyExtent {
+    nodes: number;
+    links: number;
+    columns: number;
+    valueMax: number;
+    columnMax: number;
+}
+export interface SankeyNodeRect {
+    index: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rank: number;
+}
+export interface SankeyLinkRibbon {
+    index: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    width: number;
+}
+export interface SankeyLayoutResult {
+    nodes: SankeyNodeRect[];
+    links: SankeyLinkRibbon[];
+    columns: number;
+    nodeWidth: number;
+    nodePadding: number;
+    scale: number;
+    iterations: number;
+    width: number;
+    height: number;
+}
+export interface SankeyNodeEventDetail {
+    kind: 'node';
+    index: number;
+    id: string;
+    label: string;
+    column: number;
+    row: number;
+    value: number;
+    inValue: number;
+    outValue: number;
+    links: number;
+    sourceIds: string[];
+    targetIds: string[];
+    selected: boolean;
+    cssX: number;
+    cssY: number;
+}
+export interface SankeyLinkEventDetail {
+    kind: 'link';
+    index: number;
+    source: string;
+    target: string;
+    sourceIndex: number;
+    targetIndex: number;
+    value: number;
+    selected: boolean;
+    cssX: number;
+    cssY: number;
+}
+export type SankeyHitDetail = SankeyNodeEventDetail | SankeyLinkEventDetail;
+export interface SankeySelection {
+    node: SankeyNodeEventDetail | null;
+    link: SankeyLinkEventDetail | null;
+}
+export type SankeySelectionSource = 'pointer' | 'keyboard' | 'method' | 'data';
+export interface SankeySelectionChangeEventDetail extends SankeySelection {
+    by: SankeySelectionSource;
+}
+export interface SankeyDrawStats {
+    nodes: number;
+    links: number;
+    drawn: number;
+    instances: number;
+    bytes: number;
+    uploaded: number;
+    full: boolean;
+    version: number;
+    nodeWidthPx: number;
+    nodePaddingPx: number;
+    columns: number;
+    curvature: number;
+    dim: number;
+    activeNode: number;
+    activeLink: number;
+    colored: number;
+}
+export interface SankeyRenderResult {
+    points: number;
+    drawn: number;
+    renderMs: number;
+    sankey?: SankeyDrawStats;
+}
+export type SankeyEngineMode = HeatmapEngineMode;
+export type SankeyEngineTier = HeatmapEngineTier;
+export type SankeyUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export type SankeyEasing = HeatmapEasing;
+export type SankeyAnimationType = HeatmapAnimationType;
+export interface SankeyStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    entries: SankeyLinkInput[];
+    replaced: number;
+}
+export interface SankeyStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(link: SankeyLinkInput): void;
+    pushBatch(links: ReadonlyArray<SankeyLinkInput>): void;
+    shift(count: number): void;
+    replace(links: ReadonlyArray<SankeyLinkInput>): void;
+    snapshot(): SankeyLinkInput[];
+    subscribe(listener: (event: SankeyStreamEvent) => void): () => void;
+}

package/dist/types/components/chart/_shared/core/contract/scatter3d-contract.d.ts

@@ -0,0 +1,124 @@
+import type { Scene3DVector, Scene3DBounds } from './scene3d-camera-contract';
+import type { Scene3DDataSpace, Scene3DDomain, Scene3DAxesOptions } from './scene3d-chart-contract';
+import type { HeatmapColorInput, HeatmapEngineMode, HeatmapEngineTier, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export interface Scatter3DDatum {
+    id?: string | number;
+    x: number | null;
+    y: number | null;
+    z: number | null;
+    value?: number | null;
+    radius?: number;
+    color?: string;
+    label?: string;
+}
+export type Scatter3DTuple = readonly [
+    number | null,
+    number | null,
+    number | null,
+    (number | null)?
+];
+export type Scatter3DData = ReadonlyArray<Scatter3DDatum | Scatter3DTuple>;
+export interface Scatter3DPoint extends Scatter3DDatum {
+    index: number;
+    key: string;
+    valid: boolean;
+    value: number | null;
+}
+export interface Scatter3DDiagnostics {
+    points: number;
+    validPoints: number;
+    missingCoordinates: number;
+    invalidCoordinates: number;
+    missingValues: number;
+}
+export interface Scatter3DDataset {
+    points: ReadonlyArray<Scatter3DPoint>;
+    diagnostics: Scatter3DDiagnostics;
+}
+export type Scatter3DMarker = 'sphere' | 'cube';
+export interface Scatter3DLayoutOptions {
+    size?: Scene3DVector;
+    marker?: Scatter3DMarker;
+    markerRadius?: number;
+    detail?: 0 | 1 | 2;
+    colors?: HeatmapColorInput;
+    colorDomain?: Scene3DDomain;
+    missingColor?: string;
+}
+export interface Scatter3DGeometry extends Scene3DDataSpace {
+    points: number;
+    drawn: number;
+    triangles: number;
+    positions: Float32Array;
+    normals: Float32Array;
+    colors: Float32Array;
+    indices: Uint32Array;
+    pointIndices: Uint32Array;
+    trianglePoints: Uint32Array;
+    colorDomain: Scene3DDomain;
+    bounds: Scene3DBounds;
+}
+export interface Scatter3DHitDetail {
+    kind: 'scatter3d';
+    point: Scatter3DPoint;
+    pointIndex: number;
+    world: Scene3DVector;
+    center: Scene3DVector;
+    cssX: number;
+    cssY: number;
+    depth: number;
+    triangle: number;
+}
+export interface Scatter3DSelection {
+    point: Scatter3DPoint | null;
+}
+export type Scatter3DSelectionSource = 'pointer' | 'keyboard' | 'method' | 'data';
+export interface Scatter3DSelectionChangeEventDetail extends Scatter3DSelection {
+    by: Scatter3DSelectionSource;
+}
+export interface Scatter3DCrosshairDetail {
+    cssX: number;
+    cssY: number;
+    dataX: number;
+    dataY: number;
+    dataZ: number;
+    point: Scatter3DPoint;
+    snapped: boolean;
+}
+export interface Scatter3DStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    replaced: number;
+    entries: Scatter3DDatum[];
+}
+export interface Scatter3DStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(point: Scatter3DDatum): void;
+    pushBatch(points: ReadonlyArray<Scatter3DDatum>): void;
+    shift(count: number): void;
+    replace(points: ReadonlyArray<Scatter3DDatum>): void;
+    setCapacity(capacity: number): void;
+    snapshot(): Scatter3DDatum[];
+    subscribe(listener: (event: Scatter3DStreamEvent) => void): () => void;
+}
+export interface Scatter3DRenderResult {
+    points: number;
+    drawn: number;
+    renderMs: number;
+    scatter3d?: {
+        triangles: number;
+        vertices: number;
+        chunks: number;
+        drawCalls: number;
+        uploadedBytes: number;
+    };
+}
+export type Scatter3DAxesOptions = Scene3DAxesOptions;
+export type Scatter3DEngineMode = HeatmapEngineMode;
+export type Scatter3DEngineTier = HeatmapEngineTier;
+export type Scatter3DUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export type Scatter3DDomain = Scene3DDomain;
+export type Scatter3DEasing = import('./heatmap-contract').HeatmapEasing;
+export type Scatter3DCameraChangeEventDetail = import('./scene3d-chart-contract').Scene3DCameraChangeEventDetail;

package/dist/types/components/chart/_shared/core/contract/scene3d-camera-contract.d.ts

@@ -0,0 +1,27 @@
+export type Scene3DVector = readonly [
+    number,
+    number,
+    number
+];
+export type Scene3DProjection = 'perspective' | 'orthographic';
+export interface Scene3DCameraOptions {
+    projection?: Scene3DProjection;
+    position?: Scene3DVector;
+    target?: Scene3DVector;
+    up?: Scene3DVector;
+    fovY?: number;
+    height?: number;
+    zoom?: number;
+    near?: number;
+    far?: number;
+}
+export interface Scene3DViewport {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+}
+export interface Scene3DBounds {
+    min: Scene3DVector;
+    max: Scene3DVector;
+}

package/dist/types/components/chart/_shared/core/contract/scene3d-chart-contract.d.ts

@@ -0,0 +1,29 @@
+import type { Scene3DVector } from './scene3d-camera-contract';
+export type Scene3DAxis = 'x' | 'y' | 'z';
+export type Scene3DDomain = readonly [
+    number,
+    number
+];
+export interface Scene3DDataSpace {
+    size: Scene3DVector;
+    domains: Record<Scene3DAxis, Scene3DDomain>;
+}
+export interface Scene3DAxesOptions {
+    show?: boolean;
+    gridLines?: boolean;
+    tickCount?: number;
+    xTitle?: string;
+    yTitle?: string;
+    zTitle?: string;
+    color?: string;
+    gridColor?: string;
+    textColor?: string;
+    format?: (value: number, axis: Scene3DAxis) => string;
+    tickValues?: Partial<Record<Scene3DAxis, ReadonlyArray<number>>>;
+}
+export interface Scene3DCameraChangeEventDetail {
+    camera: import('./scene3d-camera-contract').Scene3DCameraOptions;
+    by: 'pointer' | 'wheel' | 'keyboard' | 'api' | 'damping' | 'auto';
+    phase: 'start' | 'change' | 'end';
+    cancelled?: boolean;
+}

package/dist/types/components/chart/_shared/core/contract/scene3d-lighting-contract.d.ts

@@ -0,0 +1,42 @@
+import type { Scene3DVector, Scene3DProjection } from './scene3d-camera-contract';
+export type Scene3DRgb = readonly [
+    number,
+    number,
+    number
+];
+export interface Scene3DMaterialOptions {
+    shading?: 'unlit' | 'phong';
+    diffuse?: Scene3DRgb;
+    specular?: Scene3DRgb;
+    emissive?: Scene3DRgb;
+    shininess?: number;
+    normalMode?: 'smooth' | 'flat';
+    twoSided?: boolean;
+}
+export interface Scene3DLightColor {
+    color?: Scene3DRgb;
+    intensity?: number;
+}
+export interface Scene3DDirectionalLight extends Scene3DLightColor {
+    type: 'directional';
+    direction: Scene3DVector;
+}
+export interface Scene3DPointLight extends Scene3DLightColor {
+    type: 'point';
+    position: Scene3DVector;
+    attenuation?: {
+        constant?: number;
+        linear?: number;
+        quadratic?: number;
+    };
+}
+export type Scene3DLight = Scene3DDirectionalLight | Scene3DPointLight;
+export interface Scene3DLightingOptions {
+    ambient?: Scene3DLightColor;
+    lights?: ReadonlyArray<Scene3DLight>;
+}
+export interface Scene3DLightingView {
+    projection?: Scene3DProjection;
+    position?: Scene3DVector;
+    direction?: Scene3DVector;
+}

package/dist/types/components/chart/_shared/core/contract/scene3d-orbit-contract.d.ts

@@ -0,0 +1,38 @@
+import type { Scene3DVector } from './scene3d-camera-contract';
+export type Orbit3DAction = 'rotate' | 'pan' | 'dolly' | 'none';
+export interface Orbit3DOptions {
+    enabled?: boolean;
+    enableRotate?: boolean;
+    enablePan?: boolean;
+    enableZoom?: boolean;
+    rotateSpeed?: number;
+    panSpeed?: number;
+    zoomSpeed?: number;
+    minDistance?: number;
+    maxDistance?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    minPolarAngle?: number;
+    maxPolarAngle?: number;
+    minAzimuthAngle?: number;
+    maxAzimuthAngle?: number;
+    screenSpacePanning?: boolean;
+    zoomToCursor?: boolean;
+    targetCenter?: Scene3DVector;
+    minTargetRadius?: number;
+    maxTargetRadius?: number;
+    enableDamping?: boolean;
+    dampingTime?: number;
+    autoRotate?: boolean;
+    autoRotateSpeed?: number;
+    reducedMotion?: boolean;
+    keyPanSpeed?: number;
+    keyRotateSpeed?: number;
+    mouseButtons?: {
+        left?: Orbit3DAction;
+        middle?: Orbit3DAction;
+        right?: Orbit3DAction;
+    };
+    oneTouch?: 'rotate' | 'pan' | 'none';
+    twoTouch?: 'dolly-pan' | 'dolly-rotate' | 'pan' | 'none';
+}

package/dist/types/components/chart/_shared/core/contract/spectrogram-contract.d.ts

@@ -0,0 +1,82 @@
+import type { HeatmapAnimationType, HeatmapEasing, HeatmapEngineMode, HeatmapEngineTier, HeatmapLodMode, HeatmapPlaneStats, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export type SpectrogramFrame = ArrayLike<number>;
+export interface SpectrogramColumns {
+    frames: number;
+    bins: number;
+    values: ArrayLike<number>;
+}
+export type SpectrogramInput = ReadonlyArray<SpectrogramFrame> | SpectrogramColumns;
+export type SpectrogramValueScale = 'db' | 'linear';
+export type SpectrogramWindowKind = 'hann' | 'hamming' | 'blackman' | 'rect';
+export interface SpectrogramFftInfo {
+    fftSize: number;
+    hop: number;
+    window: SpectrogramWindowKind;
+    bins: number;
+    sampleRate: number;
+    binHz: number;
+    frameSeconds: number;
+    coherentGain: number;
+}
+export interface SpectrogramAppendSamplesResult {
+    frames: number;
+    pending: number;
+}
+export type SpectrogramEngineMode = HeatmapEngineMode;
+export type SpectrogramEngineTier = HeatmapEngineTier;
+export type SpectrogramUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export type SpectrogramEasing = HeatmapEasing;
+export type SpectrogramAnimationType = HeatmapAnimationType;
+export type SpectrogramLodMode = HeatmapLodMode;
+export interface SpectrogramPointEventDetail {
+    frame: number;
+    bin: number;
+    index: number;
+    time: number;
+    frequency: number;
+    value: number | null;
+    cssX: number;
+    cssY: number;
+}
+export interface SpectrogramRenderResult {
+    frames: number;
+    bins: number;
+    drawn: number;
+    renderMs: number;
+    plane?: HeatmapPlaneStats;
+}
+export interface SpectrogramValueExtent {
+    min: number;
+    max: number;
+    finite: number;
+}
+export interface SpectrogramRanges {
+    time: {
+        start: number;
+        end: number;
+        hop: number;
+    };
+    frequency: {
+        min: number;
+        max: number;
+        bins: number;
+    };
+    dropped: number;
+}
+export interface SpectrogramStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    frames: ReadonlyArray<SpectrogramFrame>;
+}
+export interface SpectrogramStreamSource {
+    push(frame: SpectrogramFrame): void;
+    pushBatch(frames: ReadonlyArray<SpectrogramFrame>): void;
+    shift(count: number): void;
+    replace(frames: ReadonlyArray<SpectrogramFrame>): void;
+    snapshot(): SpectrogramFrame[];
+    latest(): SpectrogramFrame | undefined;
+    subscribe(listener: (event: SpectrogramStreamEvent) => void): () => void;
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+}

package/dist/types/components/chart/_shared/core/contract/sunburst-contract.d.ts

@@ -0,0 +1,145 @@
+import type { HeatmapAnimationType, HeatmapEasing, HeatmapEngineMode, HeatmapEngineTier, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export interface SunburstNodeInput {
+    id: string;
+    label?: string;
+    color?: string;
+    parent?: string | null;
+    value?: number;
+    children?: ReadonlyArray<SunburstNodeInput>;
+}
+export type SunburstData = SunburstNodeInput | ReadonlyArray<SunburstNodeInput>;
+export interface SunburstNode {
+    index: number;
+    id: string;
+    label: string;
+    color: string | null;
+    parent: number | null;
+    children: number[];
+    depth: number;
+    ownValue: number;
+    value: number;
+    origin: 'data' | 'stream';
+}
+export interface SunburstDiagnostics {
+    invalidIds: number;
+    invalidValues: number;
+    duplicates: number;
+    missingParents: number;
+    cycles: number;
+    objectCycles: number;
+}
+export interface SunburstTree {
+    nodes: SunburstNode[];
+    roots: number[];
+    total: number;
+    diagnostics: SunburstDiagnostics;
+}
+export interface SunburstExtent {
+    nodes: number;
+    leaves: number;
+    total: number;
+    depth: number;
+    valueMax: number;
+}
+export type SunburstLayout = 'partition';
+export type SunburstLabelMode = 'auto' | 'show' | 'hide';
+export interface SunburstLabel {
+    index: number;
+    id: string;
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    shown: boolean;
+    opacity: number;
+    color: string;
+}
+export interface SunburstArc {
+    cx: number;
+    cy: number;
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+    index: number;
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+    opacity: number;
+    passive?: boolean;
+    paintOrder?: number;
+}
+export interface SunburstLayoutResult {
+    nodes: SunburstArc[];
+    width: number;
+    height: number;
+    total: number;
+    rootId: string | null;
+    layout: SunburstLayout;
+}
+export type SunburstSelectionSource = 'pointer' | 'keyboard' | 'method' | 'data';
+export interface SunburstHitDetail {
+    kind: 'node';
+    nodeIndex: number;
+    node: SunburstNode;
+    cssX: number;
+    cssY: number;
+    value: number;
+}
+export interface SunburstSelection {
+    nodeIndex: number;
+    node: SunburstNode | null;
+}
+export interface SunburstSelectionChangeEventDetail extends SunburstSelection {
+    by: SunburstSelectionSource;
+}
+export interface SunburstDrillChangeEventDetail {
+    rootId: string | null;
+    previousRootId: string | null;
+    by: SunburstSelectionSource;
+}
+export interface SunburstStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    entries: SunburstNodeInput[];
+    replaced: number;
+}
+export interface SunburstStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(node: SunburstNodeInput): void;
+    pushBatch(nodes: ReadonlyArray<SunburstNodeInput>): void;
+    shift(count: number): void;
+    replace(nodes: ReadonlyArray<SunburstNodeInput>): void;
+    snapshot(): SunburstNodeInput[];
+    subscribe(listener: (event: SunburstStreamEvent) => void): () => void;
+}
+export interface SunburstRenderResult {
+    points: number;
+    drawn: number;
+    renderMs: number;
+    sunburst?: {
+        nodes: number;
+        drawn: number;
+        vertices: number;
+        bytes: number;
+        uploaded: number;
+        full: boolean;
+        version: number;
+        activeNode: number;
+        chunks: number;
+        chunkVertices: number;
+        capacity: number;
+        cut: number;
+    };
+}
+export type SunburstAnimationType = HeatmapAnimationType;
+export type SunburstEasing = HeatmapEasing;
+export type SunburstEngineMode = HeatmapEngineMode;
+export type SunburstEngineTier = HeatmapEngineTier;
+export type SunburstUnavailableBehaviour = HeatmapUnavailableBehaviour;