@univerjs-pro/engine-chart 0.25.1 → 1.0.0-alpha.1

package/lib/types/wordcloud-chart/core/collision/bitset-board.d.ts

@@ -0,0 +1,45 @@
+export interface IPixelBitsetBoard {
+    readonly width: number;
+    readonly height: number;
+    readonly stride: number;
+    readonly words: Uint32Array;
+    blockedPixelCount: number;
+    occupiedPixelCount: number;
+}
+export interface IPixelBitsetSprite {
+    readonly width: number;
+    readonly height: number;
+    readonly stride: number;
+    readonly words: Uint32Array;
+    readonly activeWords: readonly IPixelBitsetSpriteWord[];
+    readonly activeWordCount: number;
+    readonly alphaPixelCount: number;
+}
+export interface IPixelBitsetSpriteWord {
+    readonly row: number;
+    readonly wordIndex: number;
+    readonly bits: number;
+}
+export interface ICreateBitsetBoardOptions {
+    readonly shapeMask?: Uint8Array;
+}
+export interface ICreateBitsetSpriteOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly pixels: Uint8Array;
+}
+export interface ICreateBitsetSpriteFromSpansOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly spans: readonly IPixelBitsetSpriteSpan[];
+}
+export interface IPixelBitsetSpriteSpan {
+    readonly y: number;
+    readonly x0: number;
+    readonly x1: number;
+}
+export declare function createBitsetBoard(width: number, height: number, options?: ICreateBitsetBoardOptions): IPixelBitsetBoard;
+export declare function createBitsetSpriteFromPixels(options: ICreateBitsetSpriteOptions): IPixelBitsetSprite;
+export declare function createBitsetSpriteFromSpans(options: ICreateBitsetSpriteFromSpansOptions): IPixelBitsetSprite;
+export declare function collideSprite(board: IPixelBitsetBoard, sprite: IPixelBitsetSprite, left: number, top: number): boolean;
+export declare function stampSprite(board: IPixelBitsetBoard, sprite: IPixelBitsetSprite, left: number, top: number): void;

package/lib/types/wordcloud-chart/core/collision/box-shape-engine.d.ts

@@ -0,0 +1,31 @@
+import type { IWordCloudEncodedWord } from '../../types';
+import type { IBoxFootprint, IWordCloudLayoutGrid } from '../layout/types';
+import type { ICollisionCandidate, ICollisionEngine, ICollisionEngineStats, ICollisionTextStyle } from './engine';
+export declare class BoxShapeEngine implements ICollisionEngine<IBoxFootprint> {
+    private readonly _grid;
+    private readonly _shapeGrid;
+    readonly collisionShape: "box";
+    private readonly _footprintCache;
+    private readonly _placed;
+    private readonly _spatialIndex;
+    private readonly _blockedCenters;
+    private readonly _spatialCellSize;
+    private readonly _shapeIsFull;
+    private _nextSpatialQueryId;
+    private readonly _stats;
+    private _lastShapeCheck;
+    constructor(_grid: IWordCloudLayoutGrid, _shapeGrid: Uint8Array);
+    createFootprint(_word: IWordCloudEncodedWord, style: ICollisionTextStyle, rotation: number): IBoxFootprint;
+    getBounds(footprint: IBoxFootprint, candidate: ICollisionCandidate): import("../..").IWordCloudBounds;
+    isInsideLayout(footprint: IBoxFootprint, candidate: ICollisionCandidate, width: number, height: number): boolean;
+    canPlace(footprint: IBoxFootprint, candidate: ICollisionCandidate): boolean;
+    isShapeBlocked(footprint: IBoxFootprint, candidate: ICollisionCandidate): boolean;
+    commit(footprint: IBoxFootprint, candidate: ICollisionCandidate): void;
+    getStats(): ICollisionEngineStats;
+    private isBoxInsideShape;
+    private rememberShapeCheck;
+    private getRememberedShapeCheck;
+    private visitNearby;
+    private insertSpatial;
+    private isCandidateCenterBlocked;
+}

package/lib/types/wordcloud-chart/core/collision/engine.d.ts

@@ -0,0 +1,67 @@
+import type { IWordCloudBounds, IWordCloudClipMask, IWordCloudEncodedWord, IWordCloudTextMeasurer, IWordCloudTextSprite } from '../../types';
+import type { IWordCloudLayoutGrid } from '../layout/types';
+export type WordCloudCollisionShape = 'box' | 'glyph';
+export type WordCloudRejectReason = 'collision' | 'shape';
+export interface ICollisionEngineStats {
+    readonly spatialQueryCount: number;
+    readonly avgNearbyBoxCount: number;
+    readonly aabbRejectCount: number;
+    readonly satTestCount: number;
+    readonly satCollisionCount: number;
+    readonly shapeSampleCheckCount?: number;
+    readonly centerInsideRejectCount?: number;
+    readonly centerBlockCacheHitCount?: number;
+    readonly pixelCanPlaceCallCount?: number;
+    readonly pixelCanPlaceRejectCount?: number;
+    readonly pixelIsShapeBlockedCallCount?: number;
+    readonly pixelSpriteCacheHit?: number;
+    readonly pixelSpriteCacheMiss?: number;
+}
+export interface ICollisionTextStyle {
+    readonly width: number;
+    readonly height: number;
+    readonly padding: number;
+    readonly dpr?: number;
+    readonly sprite?: IWordCloudTextSprite;
+}
+export interface ICollisionCandidate {
+    readonly index: number;
+    readonly row: number;
+    readonly col: number;
+    readonly x: number;
+    readonly y: number;
+}
+export interface ICollisionFootprint {
+    readonly key: string;
+    readonly staticKey?: string;
+    readonly width: number;
+    readonly height: number;
+    readonly rawWidth: number;
+    readonly rawHeight: number;
+    readonly angle: number;
+}
+export interface ICollisionShapeEngine<TFootprint extends ICollisionFootprint = ICollisionFootprint> {
+    readonly collisionShape: WordCloudCollisionShape;
+    readonly cacheCollisionFailures?: boolean;
+    createFootprint(word: IWordCloudEncodedWord, style: ICollisionTextStyle, rotation: number): TFootprint;
+    getBounds(footprint: TFootprint, candidate: ICollisionCandidate): IWordCloudBounds;
+    canPossiblyPlace?(footprint: TFootprint): boolean;
+    getPossibleRejectReason?(footprint: TFootprint): WordCloudRejectReason;
+    isInsideLayout?(footprint: TFootprint, candidate: ICollisionCandidate, width: number, height: number): boolean;
+    canPlace(footprint: TFootprint, candidate: ICollisionCandidate): boolean;
+    canPlaceBounds?(footprint: TFootprint, bounds: IWordCloudBounds): boolean;
+    isShapeBlocked?(footprint: TFootprint, candidate: ICollisionCandidate): boolean;
+    getClipBounds?(footprint: TFootprint, candidate: ICollisionCandidate): IWordCloudBounds | undefined;
+    getClipMask?(footprint: TFootprint, candidate: ICollisionCandidate): IWordCloudClipMask | undefined;
+    getStats?(): ICollisionEngineStats;
+    commit(footprint: TFootprint, candidate: ICollisionCandidate): void;
+}
+export type ICollisionEngine<TFootprint extends ICollisionFootprint = ICollisionFootprint> = ICollisionShapeEngine<TFootprint>;
+export interface ICollisionEngineContext {
+    readonly grid: IWordCloudLayoutGrid;
+    readonly shapeGrid: Uint8Array;
+    readonly measurer: IWordCloudTextMeasurer;
+    readonly drawOutOfBound?: boolean;
+}
+export declare function normalizeCollisionShape(shape: unknown): WordCloudCollisionShape;
+export declare function createCollisionShapeEngine(shape: WordCloudCollisionShape, context: ICollisionEngineContext): ICollisionShapeEngine;

package/lib/types/wordcloud-chart/core/collision/failure-cache.d.ts

@@ -0,0 +1,6 @@
+export declare class WordCloudFailureCache {
+    private readonly _limit;
+    private readonly _entries;
+    constructor(limit: number);
+    get(key: string, size: number): Uint8Array | undefined;
+}

package/lib/types/wordcloud-chart/core/collision/footprint.d.ts

@@ -0,0 +1,13 @@
+import type { IWordCloudBounds, IWordCloudMeasureResult } from '../../types';
+import type { IBoxFootprint, IWordCloudLayoutGrid } from './types';
+export interface IBoxTightTextBox {
+    readonly width: number;
+    readonly height: number;
+    readonly angle: number;
+    readonly corners: ReadonlyArray<readonly [number, number]>;
+    readonly bounds: IWordCloudBounds;
+}
+export declare function createBoxFromTightTextBox(textMetrics: IWordCloudMeasureResult, angle: number, padding: number): IBoxTightTextBox;
+export declare function createBoxFootprint(grid: IWordCloudLayoutGrid, rawWidth: number, rawHeight: number, angle: number): IBoxFootprint;
+export declare function getCachedBoxFootprint(cache: Map<string, IBoxFootprint>, grid: IWordCloudLayoutGrid, rawWidth: number, rawHeight: number, angle: number): IBoxFootprint;
+export declare function getBoxBounds(x: number, y: number, footprint: IBoxFootprint): IWordCloudBounds;

package/lib/types/wordcloud-chart/core/collision/glyph-shape-engine.d.ts

@@ -0,0 +1,49 @@
+import type { IWordCloudBounds, IWordCloudClipMask, IWordCloudEncodedWord, IWordCloudTextMeasurer } from '../../types';
+import type { IWordCloudLayoutGrid } from '../layout/types';
+import type { IPixelBitsetSprite } from './bitset-board';
+import type { ICollisionCandidate, ICollisionEngine, ICollisionFootprint, ICollisionTextStyle } from './engine';
+interface IPixelSpan {
+    readonly y: number;
+    readonly x0: number;
+    readonly x1: number;
+}
+export interface IPixelFootprint extends ICollisionFootprint {
+    readonly anchorX: number;
+    readonly anchorY: number;
+    readonly pixels: Uint8Array;
+    readonly sprite: IPixelBitsetSprite;
+    readonly rowSpans: readonly IPixelSpan[];
+}
+export declare class GlyphShapeEngine implements ICollisionEngine<IPixelFootprint> {
+    private readonly _grid;
+    private readonly _shapeGrid;
+    private readonly _measurer;
+    private readonly _cacheLimit;
+    private readonly _clipToShape;
+    readonly collisionShape: "glyph";
+    readonly cacheCollisionFailures = false;
+    private readonly _spriteCache;
+    private readonly _board;
+    private readonly _shapeBoard;
+    private _lastClip;
+    constructor(_grid: IWordCloudLayoutGrid, _shapeGrid: Uint8Array, _measurer: IWordCloudTextMeasurer, _cacheLimit?: number, _clipToShape?: boolean);
+    createFootprint(word: IWordCloudEncodedWord, style: ICollisionTextStyle, rotation: number): IPixelFootprint;
+    getBounds(footprint: IPixelFootprint, candidate: ICollisionCandidate): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    canPossiblyPlace(footprint: IPixelFootprint): boolean;
+    getPossibleRejectReason(footprint: IPixelFootprint): 'shape' | 'collision';
+    isInsideLayout(footprint: IPixelFootprint, candidate: ICollisionCandidate, width: number, height: number): boolean;
+    canPlace(footprint: IPixelFootprint, candidate: ICollisionCandidate): boolean;
+    canPlaceBounds(footprint: IPixelFootprint, bounds: IWordCloudBounds): boolean;
+    isShapeBlocked(footprint: IPixelFootprint, candidate: ICollisionCandidate): boolean;
+    getClipBounds(footprint: IPixelFootprint, candidate: ICollisionCandidate): IWordCloudBounds | undefined;
+    getClipMask(footprint: IPixelFootprint, candidate: ICollisionCandidate): IWordCloudClipMask | undefined;
+    private canPlaceAt;
+    commit(footprint: IPixelFootprint, candidate: ICollisionCandidate): void;
+    private getClippedPlacement;
+}
+export {};

package/lib/types/wordcloud-chart/core/collision/grid.d.ts

@@ -0,0 +1,10 @@
+import type { IBoxFootprint, IWordCloudLayoutGrid } from './types';
+export declare function createWordCloudGrid(width: number, height: number, cellSize: number): IWordCloudLayoutGrid;
+export declare function getCellCenter(grid: IWordCloudLayoutGrid, index: number): {
+    row: number;
+    col: number;
+    x: number;
+    y: number;
+};
+export declare function getCellIndex(grid: IWordCloudLayoutGrid, row: number, col: number): number;
+export declare function commitBoxFootprint(grid: IWordCloudLayoutGrid, footprint: IBoxFootprint, centerIndex: number): void;

package/lib/types/wordcloud-chart/core/collision/types.d.ts

@@ -0,0 +1 @@
+export type * from '../types/layout';

package/lib/types/wordcloud-chart/core/layout/candidates.d.ts

@@ -0,0 +1,15 @@
+import type { ICollisionCandidate } from '../collision/engine';
+import type { IWordCloudShapeProfile } from '../shape/shape-profile';
+import type { IWordCloudPlacementContext } from './placement-types';
+import type { IPreparedWordCloudWord, IWordCloudLayoutConfig, IWordCloudLayoutGrid, IWordCloudLayoutRuntime } from './types';
+export interface IEnumerateCandidatePointsOptions {
+    readonly grid: IWordCloudLayoutGrid;
+    readonly shapeGrid: Uint8Array;
+    readonly maxPoints: number;
+    readonly stepCells?: number;
+    readonly shapeProfile?: IWordCloudShapeProfile;
+}
+export declare function enumerateCandidatePoints(options: IEnumerateCandidatePointsOptions): ICollisionCandidate[];
+export declare function createFineCandidatePoints(context: IWordCloudPlacementContext, primaryCandidatePoints: readonly ICollisionCandidate[]): ICollisionCandidate[];
+export declare function shouldUseFinePixelCandidates(word: IPreparedWordCloudWord, config: IWordCloudLayoutConfig, runtime: IWordCloudLayoutRuntime): boolean;
+export declare function getFineCandidateMultiplier(context: IWordCloudPlacementContext): number;

package/lib/types/wordcloud-chart/core/layout/font-scale.d.ts

@@ -0,0 +1,66 @@
+/**
+ * wordcloud-font-size-scale.ts
+ *
+ * A single-file implementation of the reference wordCloud font-size pipeline.
+ *
+ * Scope:
+ * - This file copies the *font size mapping* behavior used by the ordinary wordCloud transform:
+ *   value field -> signed sqrt scale -> fontSizeRange.
+ * What this intentionally does NOT do:
+ * - It does not copy the full pixel/grid collision layout. If you need 1:1 placement, use @visactor/vlayouts
+ *   directly. This file is for engines that already have their own tryPlaceWord/layout implementation.
+ *
+ * Notes from upstream behavior:
+ * - The chart layer passes fontSize as { field: valueField } and fontSizeRange as the configured range.
+ * - When fontSizeRange === 'auto', it passes null to the layout transform.
+ * - The ordinary VGrammar wordcloud transform only applies fontSizeRange when fontSize is not a fixed number.
+ * - The scale is sqrt-based, with signed sqrt support for negative numbers.
+ * - If the data has exactly one item, extent shifts min downward so the single word maps to the max font size.
+ *
+ * License note:
+ * - This is an MIT-compatible source-level port of small algorithmic utilities from VisActor/VGrammar.
+ *   Keep this header if copied into your project.
+ */
+export interface IFieldOption {
+    field: string;
+}
+export type CallbackOption<T, R = any> = (datum: T, index: number, data: T[]) => R;
+export interface IWordCloudFontSizeMeta {
+    /** Effective range after applying the `fontSizeRange === 'auto' ? null : range` rule. */
+    effectiveFontSizeRange: [number, number] | null;
+    /** Data extent used before sqrt scale. */
+    extent: [number, number] | null;
+    /** True when field/callback fontSize is mapped through sqrt scale. */
+    usedSqrtRangeScale: boolean;
+    /** True when fontSize is a fixed number and range is ignored. */
+    fixedFontSize: boolean;
+}
+export declare const WORD_CLOUD_DEFAULT_FONT_SIZE_RANGE: [number, number];
+/**
+ * Direct port of VGrammar's fontSize + fontSizeRange decision:
+ * - `fontSize = field(options.fontSize) || 14`
+ * - `fontSizeRange` applies only when fontSize is not a fixed number
+ * - mapping is sqrt scale over extent(data)
+ */
+export declare function createWordCloudFontSizeAccessor<T extends Record<string, any>>(data: T[], options: {
+    fontSize?: IFieldOption | CallbackOption<T, number> | number;
+    fontSizeRange?: [number, number] | null;
+}): {
+    fontSize: CallbackOption<T, number>;
+    sourceValue: CallbackOption<T, number>;
+    meta: IWordCloudFontSizeMeta;
+};
+/**
+ * Chart rule: spec.fontSizeRange === 'auto' is passed to the transform as null.
+ * For ordinary wordcloud, null means "do not run fontSizeRange sqrt mapping here".
+ */
+export declare function normalizeWordCloudFontSizeRange(fontSizeRange: [number, number] | 'auto' | null | undefined): [number, number] | null;
+/** Signed sqrt used by VGrammar wordcloud scale. */
+export declare function signedSqrt(x: number): number;
+/**
+ * Direct port of VGrammar `generateScale(extent, range)` for font size.
+ * Note: VGrammar's `type` argument exists but sqrt behavior is used by default.
+ */
+export declare function generateWordCloudSqrtScale(domain: [number, number], range: [number, number]): (datum: number) => number;
+/** Direct port of VGrammar extent behavior, including the single-data max-size trick. */
+export declare function extent<T extends Record<string, any>>(fieldAccessor: CallbackOption<T, number>, data: T[]): [number, number];

package/lib/types/wordcloud-chart/core/layout/layout-config.d.ts

@@ -0,0 +1,3 @@
+import type { IWordCloudLayoutOptions } from '../../types';
+import type { IWordCloudLayoutConfig } from './types';
+export declare function resolveWordCloudLayoutConfig(options: IWordCloudLayoutOptions): IWordCloudLayoutConfig;

package/lib/types/wordcloud-chart/core/layout/layout.d.ts

@@ -0,0 +1,4 @@
+import type { IWordCloudEncodedWord, IWordCloudLayoutOptions, IWordCloudLayoutResult } from '../../types';
+import type { IWordCloudLayoutRuntime } from './types';
+export declare function layoutWordCloudGridWords(words: readonly IWordCloudEncodedWord[], options: IWordCloudLayoutOptions, runtime: IWordCloudLayoutRuntime): IWordCloudLayoutResult;
+export declare const layoutWordCloud: typeof layoutWordCloudGridWords;

package/lib/types/wordcloud-chart/core/layout/phases.d.ts

@@ -0,0 +1,12 @@
+import type { IWordCloudEncodedWord, IWordCloudPlacedWord } from '../../types';
+import type { IPreparedWordCloudWord, IWordCloudLayoutConfig, IWordCloudLayoutGrid, IWordCloudLayoutRuntime } from './types';
+import type { IWordCloudShapeProfile } from '../shape/shape-profile';
+import { layoutWords } from './place-word';
+export interface IWordCloudLayoutPhasesResult {
+    readonly prepared: IPreparedWordCloudWord[];
+    readonly placedByKey: Map<string, IWordCloudPlacedWord>;
+    readonly fillingWords: IWordCloudPlacedWord[];
+    readonly stats: NonNullable<ReturnType<typeof layoutWords>['stats']>;
+}
+export declare function createInvisibleWordCloudWord(word: IWordCloudEncodedWord): IWordCloudPlacedWord;
+export declare function layoutWordCloudPhases(words: readonly IWordCloudEncodedWord[], config: IWordCloudLayoutConfig, runtime: IWordCloudLayoutRuntime, grid: IWordCloudLayoutGrid, shapeGrid: Uint8Array, shapeProfile?: IWordCloudShapeProfile): IWordCloudLayoutPhasesResult;

package/lib/types/wordcloud-chart/core/layout/place-word.d.ts

@@ -0,0 +1,12 @@
+import type { IWordCloudLayoutStats, IWordCloudPlacedWord } from '../../types';
+import type { IWordCloudPlacementContext, IWordCloudTryPlaceResult } from './placement-types';
+import type { PlacementSearchPlan } from './search-plan';
+import type { IPreparedWordCloudWord, IWordCloudPlacement } from './types';
+export declare function tryPlaceWord(context: IWordCloudPlacementContext, word: IPreparedWordCloudWord, phase: 1 | 2, rank: number, searchPlan?: Extract<PlacementSearchPlan, {
+    action: 'process';
+}>): IWordCloudTryPlaceResult;
+export declare function placeWord(context: IWordCloudPlacementContext, word: IPreparedWordCloudWord, phase: 1 | 2, rank: number): IWordCloudPlacement | undefined;
+export declare function layoutWords(words: readonly IPreparedWordCloudWord[], context: IWordCloudPlacementContext): {
+    placedByKey: Map<string, IWordCloudPlacedWord>;
+    stats: IWordCloudLayoutStats;
+};

package/lib/types/wordcloud-chart/core/layout/placement-stats.d.ts

@@ -0,0 +1,7 @@
+import type { IWordCloudLayoutStats, IWordCloudPlacedWord } from '../../types';
+import type { IWordCloudTryPlaceResult } from './placement-types';
+import type { IPreparedWordCloudWord, IWordCloudLayoutConfig } from './types';
+export declare function createPlacementStats(): IWordCloudLayoutStats;
+export declare function recordPlacementResult(stats: IWordCloudLayoutStats | undefined, result: IWordCloudTryPlaceResult): void;
+export declare function recordSkippedPlacementResult(stats: IWordCloudLayoutStats | undefined, count?: number): void;
+export declare function finalizePlacementStats(stats: IWordCloudLayoutStats, words: readonly IPreparedWordCloudWord[], placed: Iterable<IWordCloudPlacedWord>, config: IWordCloudLayoutConfig, durationMs: number): void;

package/lib/types/wordcloud-chart/core/layout/placement-types.d.ts

@@ -0,0 +1,28 @@
+import type { IWordCloudLayoutStats } from '../../types';
+import type { ICollisionCandidate, ICollisionEngine } from '../collision/engine';
+import type { WordCloudFailureCache } from '../collision/failure-cache';
+import type { IWordCloudShapeProfile } from '../shape/shape-profile';
+import type { PlacementWordManager } from './placement-word-manager';
+import type { IWordCloudLayoutConfig, IWordCloudLayoutGrid, IWordCloudLayoutRuntime, IWordCloudPlacement } from './types';
+export interface IWordCloudPlacementContext {
+    readonly config: IWordCloudLayoutConfig;
+    readonly runtime: IWordCloudLayoutRuntime;
+    readonly grid: IWordCloudLayoutGrid;
+    readonly shapeGrid: Uint8Array;
+    readonly shapeProfile?: IWordCloudShapeProfile;
+    readonly collisionEngine: ICollisionEngine;
+    readonly wordManager?: PlacementWordManager;
+    readonly failureCache: WordCloudFailureCache;
+    readonly candidatePoints?: readonly ICollisionCandidate[];
+    readonly fineCandidatePoints?: readonly ICollisionCandidate[];
+    readonly stats?: IWordCloudLayoutStats;
+}
+export interface IWordCloudTryPlaceResult {
+    readonly placement?: IWordCloudPlacement;
+    readonly candidate?: ICollisionCandidate;
+    readonly tryCount: number;
+    readonly rejectByBounds: number;
+    readonly rejectByCollision: number;
+    readonly rejectByShape: number;
+    readonly exhausted: boolean;
+}

package/lib/types/wordcloud-chart/core/layout/placement-word-manager.d.ts

@@ -0,0 +1,23 @@
+import type { IWordCloudEncodedWord } from '../../types';
+import type { ICollisionEngine, ICollisionFootprint } from '../collision/engine';
+import type { IPreparedWordCloudWord, IWordCloudLayoutConfig, IWordCloudLayoutRuntime } from './types';
+export interface IResolvedPlacementWord {
+    readonly word: IWordCloudEncodedWord;
+    readonly footprint: ICollisionFootprint;
+    readonly rawWidth: number;
+    readonly rawHeight: number;
+    readonly fontSize: number;
+    readonly rotate: number;
+}
+export interface IPlacementWordSource {
+    resolve(): IResolvedPlacementWord;
+}
+export interface IPlacementWordSourceContext {
+    readonly config: IWordCloudLayoutConfig;
+    readonly runtime: IWordCloudLayoutRuntime;
+    readonly collisionEngine: ICollisionEngine;
+}
+export declare class PlacementWordManager {
+    private readonly _sources;
+    getWord(context: IPlacementWordSourceContext, word: IPreparedWordCloudWord): IPlacementWordSource;
+}

package/lib/types/wordcloud-chart/core/layout/rotation.d.ts

@@ -0,0 +1,10 @@
+export interface IPickRotationDegOptions {
+    readonly angles: readonly unknown[];
+    readonly seed?: string | number;
+    readonly index?: number;
+    readonly key?: string;
+    readonly text?: string;
+    readonly ratio?: number;
+}
+export declare function pickRotationDeg(options: IPickRotationDegOptions): number;
+export declare function normalizeRotationAngles(angles: readonly unknown[] | undefined): number[];

package/lib/types/wordcloud-chart/core/layout/runtime-mask.d.ts

@@ -0,0 +1,6 @@
+import type { IWordCloudBounds, IWordCloudEncodedWord } from '../../types';
+import type { ICollisionCandidate, ICollisionEngine, ICollisionFootprint } from '../collision/engine';
+import type { IWordCloudLayoutConfig, IWordCloudLayoutRuntime } from './types';
+export declare function isCandidateInsideLayout(collisionEngine: ICollisionEngine, footprint: ICollisionFootprint, candidate: ICollisionCandidate, config: IWordCloudLayoutConfig): boolean;
+export declare function runtimeMaskNeedsBounds(word: IWordCloudEncodedWord, runtime: IWordCloudLayoutRuntime, config: IWordCloudLayoutConfig): boolean;
+export declare function isCandidateInsideRuntimeMask(word: IWordCloudEncodedWord, bounds: IWordCloudBounds, runtime: IWordCloudLayoutRuntime, config: IWordCloudLayoutConfig): boolean;

package/lib/types/wordcloud-chart/core/layout/search-plan.d.ts

@@ -0,0 +1,51 @@
+import type { IWordCloudTryPlaceResult } from './placement-types';
+export interface IPlacementSearchPolicy {
+    readonly mandatoryFullSearchRank: number;
+    readonly middleFullPrimaryRank: number;
+    readonly stopTailRank: number;
+    readonly minCandidateBudget: number;
+    readonly recentWindowSize: number;
+    readonly skipConsecutiveFailureCount: number;
+    readonly stopConsecutiveFailureCount: number;
+    readonly skipRecentPlacedCount: number;
+    readonly stopRecentPlacedCount: number;
+    readonly skipPressure: number;
+    readonly stopPressure: number;
+}
+export declare const DEFAULT_PLACEMENT_SEARCH_POLICY: IPlacementSearchPolicy;
+export declare enum PlacementSearchPlanAction {
+    Process = "process",
+    SkipWord = "skip-word",
+    StopTail = "stop-tail"
+}
+export type PlacementSearchPlan = {
+    readonly action: PlacementSearchPlanAction.Process;
+    readonly primaryLimit: number;
+    readonly fineLimit: number;
+} | {
+    readonly action: PlacementSearchPlanAction.SkipWord;
+    readonly reason: string;
+} | {
+    readonly action: PlacementSearchPlanAction.StopTail;
+    readonly reason: string;
+};
+export interface IPlacementSearchPlanInput {
+    readonly rank: number;
+    readonly primaryFullLimit: number;
+    readonly fineFullLimit: number;
+}
+export declare class PlacementSearchPlanner {
+    private readonly _layoutArea;
+    private readonly _policy;
+    private _placedBoundsArea;
+    private _consecutiveFailureCount;
+    private readonly _recentResults;
+    constructor(_layoutArea: number, _policy?: IPlacementSearchPolicy);
+    createPlan(input: IPlacementSearchPlanInput): PlacementSearchPlan;
+    recordPlacementResult(result: IWordCloudTryPlaceResult): void;
+    private recordProcessPlan;
+    private getPressure;
+    private getRecentSuccessRate;
+    private getRecentPlacedCount;
+    private recordRecentResult;
+}

package/lib/types/wordcloud-chart/core/layout/types.d.ts

@@ -0,0 +1 @@
+export type * from '../types/layout';

package/lib/types/wordcloud-chart/core/layout/word-prepare.d.ts

@@ -0,0 +1,3 @@
+import type { IWordCloudEncodedWord } from '../../types';
+import type { IPreparedWordCloudWord, IWordCloudLayoutConfig } from './types';
+export declare function prepareWordCloudWords(words: readonly IWordCloudEncodedWord[], config: IWordCloudLayoutConfig): IPreparedWordCloudWord[];

package/lib/types/wordcloud-chart/core/layout/word-shrink.d.ts

@@ -0,0 +1,39 @@
+export interface IWordShrinkCandidate {
+    readonly designSize: number;
+    readonly actualSize: number;
+    readonly ratio: number;
+    readonly isDynamicShrink: boolean;
+}
+export type WordShrinkCandidate = IWordShrinkCandidate;
+export interface IWordShrinkStats {
+    readonly initialRatio: number;
+    readonly finalDynamicRatio: number;
+    readonly dynamicShrinkCount: number;
+}
+export type WordShrinkStats = IWordShrinkStats;
+export interface IWordShrinkSessionOptions {
+    readonly initialRatio: number;
+    readonly fontSizeLimitMin: number;
+    readonly maxProbeCount?: number;
+}
+export type WordShrinkSessionOptions = IWordShrinkSessionOptions;
+export declare const MAX_DYNAMIC_SHRINK_PROBE_COUNT = 16;
+export declare class WordShrinkSession {
+    private readonly _initialRatio;
+    private readonly _fontSizeLimitMin;
+    private readonly _maxProbeCount;
+    private _dynamicRatio;
+    private _previousPlacedDesignSize;
+    private _previousPlacedActualSize;
+    private _dynamicShrinkCount;
+    constructor(options: WordShrinkSessionOptions);
+    resolveInitialCandidate(designSize: number): WordShrinkCandidate;
+    iterDynamicCandidates(params: {
+        readonly designSize: number;
+        readonly currentActualSize: number;
+    }): IterableIterator<WordShrinkCandidate>;
+    commitPlaced(candidate: WordShrinkCandidate): void;
+    getDynamicRatio(): number;
+    getStats(): WordShrinkStats;
+}
+export declare function resolveMinShrinkRatio(value: unknown, fallback: number): number;

package/lib/types/wordcloud-chart/core/random/seed.d.ts

@@ -0,0 +1,3 @@
+export declare function createSeededRandom(seed: string | number): () => number;
+export declare function hashSeed(seed: string | number): number;
+export declare function stringifySeed(seed: unknown): string;

package/lib/types/wordcloud-chart/core/shape/built-in-shapes.d.ts

@@ -0,0 +1,14 @@
+import type { IWordCloudMaskGrid, IWordCloudMaskShapeSpec, IWordCloudSegmentationResult, WordCloudShape } from '../../types';
+export interface IWordCloudShapeGridOptions {
+    shapePaddingRatio?: number | null;
+}
+type BuiltinWordCloudShape = Exclude<WordCloudShape, 'cloud'>;
+export declare function createMaskGridFromShape(shape: IWordCloudMaskShapeSpec | undefined, width: number, height: number, options?: IWordCloudShapeGridOptions): IWordCloudMaskGrid | undefined;
+export declare function createBuiltinMaskGrid(shape: BuiltinWordCloudShape, width: number, height: number, options?: IWordCloudShapeGridOptions): IWordCloudMaskGrid;
+export declare function createBuiltinMaskGrid(shape: WordCloudShape, width: number, height: number, options?: IWordCloudShapeGridOptions): IWordCloudMaskGrid | undefined;
+export declare function createTextMaskGrid(shape: Extract<IWordCloudMaskShapeSpec, {
+    type: 'text';
+}>, width: number, height: number): IWordCloudMaskGrid;
+export declare function normalizeMaskGrid(grid: IWordCloudMaskGrid, width?: number, height?: number): IWordCloudMaskGrid;
+export declare function segmentMaskGrid(maskGrid: IWordCloudMaskGrid): IWordCloudSegmentationResult;
+export {};

package/lib/types/wordcloud-chart/core/shape/shape-mask.d.ts

@@ -0,0 +1,12 @@
+import type { IWordCloudLayoutOptions, IWordCloudMaskGrid, WordCloudShape } from '../../types';
+import type { IWordCloudLayoutGrid, IWordCloudLayoutRuntime } from './types';
+export interface IWordCloudShapeGridOptions {
+    sampleSize?: number;
+    insideRatio?: number;
+    shape?: WordCloudShape | string;
+}
+export declare function createWordCloudShapeGrid(grid: IWordCloudLayoutGrid, maskGrid: IWordCloudMaskGrid | undefined, options?: IWordCloudShapeGridOptions): Uint8Array;
+export declare function resolveWordCloudMaskGrid(grid: IWordCloudLayoutGrid, options: IWordCloudLayoutOptions, runtime: IWordCloudLayoutRuntime): IWordCloudMaskGrid | undefined;
+export declare function getDefaultShapeSampleSize(shape: WordCloudShape | string | undefined, cellSize: number): number;
+export declare function getDefaultShapeInsideRatio(shape: WordCloudShape | string | undefined): number;
+export declare function getBuiltinShapeName(shape: IWordCloudLayoutOptions['maskShape'] | undefined): WordCloudShape | undefined;

package/lib/types/wordcloud-chart/core/shape/shape-profile.d.ts

@@ -0,0 +1,20 @@
+import type { WordCloudShape } from '../../types';
+export interface IWordCloudShapeProfileOptions {
+    readonly shapePaddingRatio?: number | null;
+    readonly angleBins?: number | null;
+}
+export interface IWordCloudShapeProfile {
+    readonly shape: BuiltinWordCloudShape;
+    readonly width: number;
+    readonly height: number;
+    readonly center: readonly [number, number];
+    readonly maxRadius: number;
+    readonly radiusBins: readonly number[];
+    readonly cosBins: readonly number[];
+    readonly sinBins: readonly number[];
+    readonly contains: (x: number, y: number) => boolean;
+    readonly radiusAt: (theta: number) => number;
+}
+export type BuiltinWordCloudShape = Exclude<WordCloudShape, 'cloud'>;
+export declare function createBuiltinShapeProfile(shape: BuiltinWordCloudShape, width: number, height: number, options?: IWordCloudShapeProfileOptions): IWordCloudShapeProfile;
+export declare function createBuiltinShapeProfile(shape: WordCloudShape, width: number, height: number, options?: IWordCloudShapeProfileOptions): IWordCloudShapeProfile | undefined;

package/lib/types/wordcloud-chart/core/shape/sprite-shape.d.ts

@@ -0,0 +1,19 @@
+import type { IWordCloudMaskGrid, IWordCloudTextSprite } from '../../types';
+export interface ISpriteShapePlacement {
+    readonly sprite: Pick<IWordCloudTextSprite, 'width' | 'height' | 'pixels' | 'anchorX' | 'anchorY' | 'dpr' | 'textMetrics'>;
+    readonly shapeMask: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+    readonly left: number;
+    readonly top: number;
+}
+export interface IClippedSpriteToShape {
+    readonly sprite: IWordCloudTextSprite;
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    readonly alphaPixelCount: number;
+}
+export declare function createShapeMask(maskGrid: IWordCloudMaskGrid | undefined, width: number, height: number): Uint8Array;
+export declare function clipSpriteToShape(options: ISpriteShapePlacement): IClippedSpriteToShape | undefined;

package/lib/types/wordcloud-chart/core/shape/types.d.ts

@@ -0,0 +1 @@
+export type * from '../types/layout';

package/lib/types/wordcloud-chart/core/text/formatter.d.ts

@@ -0,0 +1,2 @@
+import type { INormalizedWordCloudDatum, IWordCloudEncodedWord, IWordCloudSpecBase } from '../../types';
+export declare function encodeWordCloudWords(words: INormalizedWordCloudDatum[], spec: IWordCloudSpecBase): IWordCloudEncodedWord[];

package/lib/types/wordcloud-chart/core/text/measure.d.ts

@@ -0,0 +1,8 @@
+import type { IWordCloudEncodedWord, IWordCloudTextMeasurer } from '../../types';
+export interface IMeasuredBoxWord {
+    readonly word: IWordCloudEncodedWord;
+    readonly width: number;
+    readonly height: number;
+}
+export declare function createPlacementLayoutWord(source: IWordCloudEncodedWord, fontSize: number, rotate: number, padding: number): IWordCloudEncodedWord;
+export declare function measureBoxWord(source: IWordCloudEncodedWord, measurer: IWordCloudTextMeasurer, fontSize: number, rotate: number, padding: number): IMeasuredBoxWord;

package/lib/types/wordcloud-chart/core/text/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { INormalizedWordCloudDatum, IWordCloudSpecBase } from '../../types';
+export declare function normalizeWordCloudData(spec: IWordCloudSpecBase): INormalizedWordCloudDatum[];