figureone 0.15.10 → 1.0.0

package/types/js/figure/Animation/AnimationStep/ParallelAnimationStep.d.ts

@@ -0,0 +1,70 @@
+import type { OBJ_AnimationStep } from '../AnimationStep';
+import AnimationStep from '../AnimationStep';
+import type { AnimationStartTime } from '../AnimationManager';
+/**
+ * Parallel animation step options object
+ * @extends OBJ_AnimationStep
+ * @property {Array<AnimationStep>} steps animation steps to perform in parallel
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_ParallelAnimationStep = {
+    steps?: Array<AnimationStep>;
+} & OBJ_AnimationStep;
+/**
+ * Execute an array of `{@link AnimationStep}`s in parallel.
+ *
+ * ![](./apiassets/parallel_animation.gif)
+ *
+ * The parallel animation step will not complete till all steps are finished.
+ *
+ * @param {Array<AnimationStep> | OBJ_SerialAnimationStep} steps
+ * animation steps to perform in serial
+ * @extends AnimationStep
+ * @see To test examples, append them to the
+ * <a href="#animation-boilerplate">boilerplate</a>
+ *
+ * @example
+ * p.animations.new()
+ *   .inParallel([
+ *     p.animations.position({ target: [1, 0], duration: 2 }),
+ *     p.animations.scale({ target: 2, duration: 2 }),
+ *   ])
+ *   .start();
+ *
+ * @example
+ * // One of the parallel steps is a series of steps
+ * p.animations.new()
+ *   .delay(1)
+ *   .inParallel([
+ *     p.animations.builder()
+ *       .scale({ target: 0.5, duration: 1 })
+ *       .scale({ target: 2, duration: 1 })
+ *       .scale({ target: 1, duration: 2 }),
+ *     p.animations.color({ target: [0, 0, 1, 1], duration: 4 }),
+ *     p.animations.rotation({ target: Math.PI, duration: 4 }),
+ *   ])
+ *   .start();
+ * @group Animation
+ */
+export declare class ParallelAnimationStep extends AnimationStep {
+    steps: Array<AnimationStep>;
+    /**
+     * @hideconstructor
+     */
+    constructor(stepsOrOptionsIn?: Array<AnimationStep | null> | OBJ_ParallelAnimationStep, ...optionsIn: Array<OBJ_ParallelAnimationStep>);
+    _getStateProperties(): string[];
+    _getStateName(): string;
+    setTimeDelta(delta: number | null | undefined): void;
+    with(step: AnimationStep): this;
+    setTimeSpeed(oldSpeed: number, newSpeed: number, now: number): void;
+    nextFrame(now: number, speed?: number): number | null;
+    finishIfZeroDuration(): void;
+    startWaiting(): void;
+    start(startTime?: AnimationStartTime | null): void;
+    finish(cancelled?: boolean, force?: 'complete' | 'freeze' | null): void;
+    getTotalDuration(): number | null;
+    getRemainingTime(now: number): number | null;
+    _dup(): ParallelAnimationStep;
+}
+export declare function inParallel(stepsOrOptionsIn?: Array<AnimationStep | null> | OBJ_ParallelAnimationStep, ...optionsIn: Array<OBJ_ParallelAnimationStep>): ParallelAnimationStep;

package/types/js/figure/Animation/AnimationStep/SerialAnimationStep.d.ts

@@ -0,0 +1,84 @@
+import type { OBJ_AnimationStep } from '../AnimationStep';
+import AnimationStep from '../AnimationStep';
+import type { AnimationStartTime } from '../AnimationManager';
+/**
+ * Serial animation step options object
+ *
+ * @extends OBJ_AnimationStep
+ * @property {Array<AnimationStep>} [steps] animation steps to execute in series
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_SerialAnimationStep = {
+    steps?: Array<AnimationStep>;
+} & OBJ_AnimationStep;
+/**
+ * Execute an array of {@link AnimationStep}s in series.
+ *
+ * ![](./apiassets/serial_animation.gif)
+ *
+ * Often the {@link AnimationBuilder} class which extends
+ * `SerialAnimationStep` can be used to create serial animations
+ * in a more clean way.
+ *
+ * @param {Array<AnimationStep> | OBJ_SerialAnimationStep} steps
+ * animation steps to perform in serial
+ * @extends AnimationStep
+ * @see To test examples, append them to the
+ * <a href="#animation-boilerplate">boilerplate</a>
+ *
+ * @example
+ * // Using a SerialAnimation step can be cumbersome, but
+ * // can be useful if modularizing animations between files
+ * const Rot = Fig.Animation.RotationAnimationStep;
+ * const Delay = Fig.Animation.DelayAnimationStep;
+ * const Pos = Fig.Animation.PositionAnimationStep;
+ *
+ * const series = new Fig.Animation.SerialAnimationStep([
+ *   new Rot({ element: p, target: Math.PI / 2, duration: 2 }),
+ *   new Delay({ duration: 0.2 }),
+ *   new Rot({ element: p, target: Math.PI, duration: 2 }),
+ *   new Delay({ duration: 0.2 }),
+ *   new Rot({ element: p, target: 0, direction: -1, duration: 1.3, progression: 'easein' }),
+ *   new Pos({ element: p, target: [1, 0], duration: 2, progression: 'easeout' }),
+ * ]);
+ *
+ * p.animations.animations.push(series);
+ * p.animations.start()
+ *
+ * @example
+ * // Same animation but with `AnimationBuilder` (which is an extension of
+ * // `SerialAnimationStep`)
+ * p.animations.new()
+ *   .rotation({ target: Math.PI / 2, duration: 2 })
+ *   .delay(0.2)
+ *   .rotation({ target: Math.PI, duration: 2 })
+ *   .delay(0.2)
+ *   .rotation({ target: 0, duration: 1, direction: -1, progression: 'easein' })
+ *   .position({ target: [1, 0], duration: 2, progression: 'easeout' })
+ *   .start();
+ * @group Animation
+ */
+export declare class SerialAnimationStep extends AnimationStep {
+    steps: Array<AnimationStep>;
+    index: number;
+    /**
+     * @hideconstructor
+     */
+    constructor(stepsOrOptionsIn?: Array<AnimationStep> | OBJ_SerialAnimationStep, ...optionsIn: Array<OBJ_SerialAnimationStep>);
+    _getStateProperties(): string[];
+    _getStateName(): string;
+    setTimeDelta(delta: number | null | undefined): void;
+    then(step: AnimationStep | null | undefined): this;
+    startWaiting(): void;
+    start(startTime?: AnimationStartTime | null): void;
+    finishIfZeroDuration(startIndex?: number): void;
+    startStep(startTime?: AnimationStartTime | null): void;
+    setTimeSpeed(oldSpeed: number, newSpeed: number, now: number): void;
+    nextFrame(now: number, speed?: number): number | null;
+    finish(cancelled?: boolean, force?: 'complete' | 'freeze' | null): void;
+    getTotalDuration(): number | null;
+    getRemainingTime(now: number): number | null;
+    _dup(): SerialAnimationStep;
+}
+export declare function inSerial(stepsOrOptionsIn?: Array<AnimationStep> | OBJ_SerialAnimationStep, ...optionsIn: Array<OBJ_SerialAnimationStep>): SerialAnimationStep;

package/types/js/figure/Animation/AnimationStep/TriggerStep.d.ts

@@ -0,0 +1,106 @@
+import type { OBJ_AnimationStep } from '../AnimationStep';
+import AnimationStep from '../AnimationStep';
+import type { AnimationStartTime } from '../AnimationManager';
+/**
+ * {@link TriggernAnimationStep} options object
+ *
+ * @extends OBJ_AnimationStep
+ *
+ * @property {string | function(any): number | void} callback if desired, return
+ * a number from `callback` to update the duration of the trigger animation
+ * step. Doing so will make any previous calculations of remaining animation
+ * time incorrect. Make sure to initialize this step with a non-zero duration
+ * for this to work.
+ * @property {any} [payload] payload to pass to callback (`null`)
+ * @property {FigureElement} element {@link FigureElement} to associate with
+ * callback - if the `callback` is a string then this element's
+ * {@link FunctionMap} will be searched for the corresponding function
+ *
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_TriggerAnimationStep = {
+    callback?: Function;
+    payload?: any;
+    setToEnd?: string | Function;
+} & OBJ_AnimationStep;
+/**
+ * Trigger Animation Step
+ *
+ * ![](./apiassets/trigger_animation.gif)
+ *
+ * A trigger step executes a custom function
+ *
+ * A `delay` will delay the triggering of the custom function
+ * while `duration` will pad time at the end of the trigger before
+ * the animation step finishes.
+ *
+ * @extends AnimationStep
+ * @param {OBJ_TriggerAnimationStep | function(): void} options
+ *
+ * @see To test examples, append them to the
+ * <a href="#animation-boilerplate">boilerplate</a>
+ *
+ * @example
+ * // Simple trigger
+ * p.animations.new()
+ *   .position({ target: [1, 0], duration: 2 })
+ *   .trigger(() => { console.log('arrived at (1, 0)') })
+ *   .position({ target: [0, 0], duration: 2 })
+ *   .trigger(() => { console.log('arrived at (0, 0)') })
+ *   .start();
+ *
+ * @example
+ * // Trigger with delay, duration and payload
+ * const printPosition = (pos) => {
+ *   console.log(`arrived at ${pos}`);
+ * };
+ *
+ * p.animations.new()
+ *   .position({ target: [1, 0], duration: 2 })
+ *   .trigger({
+ *     delay: 1,
+ *     callback: printPosition,
+ *     payload: '(1, 0)',
+ *     duration: 1,
+ *   })
+ *   .position({ target: [0, 0], duration: 2 })
+ *   .trigger({ callback: printPosition, payload: '(0, 0)' })
+ *   .start();
+ *
+ * @example
+ * // Different ways to create a stand-alone step
+ * const step1 = p.animations.trigger({
+ *   callback: () => { console.log('arrived at (1, 0)') },
+ * });
+ * const step2 = new Fig.Animation.TriggerAnimationStep({
+ *   callback: () => { console.log('arrived at (0, 0)') },
+ * });
+ *
+ * p.animations.new()
+ *   .position({ target: [1, 0], duration: 2 })
+ *   .then(step1)
+ *   .position({ target: [0, 0], duration: 2 })
+ *   .then(step2)
+ *   .start();
+ * @group Animation
+ */
+export declare class TriggerAnimationStep extends AnimationStep {
+    callback: (string | Function) | null;
+    payload: Record<string, any> | null | undefined;
+    setToEndCallback: (string | Function) | null;
+    customProperties: Record<string, any>;
+    autoDuration: boolean;
+    /**
+     * @hideconstructor
+     */
+    constructor(triggerOrOptionsIn?: Function | OBJ_TriggerAnimationStep, ...optionsIn: Array<OBJ_TriggerAnimationStep>);
+    fnExec(idOrFn: string | Function | null, ...args: any): any;
+    _getStateProperties(): string[];
+    _getStateName(): string;
+    setFrame(): void;
+    start(startTime?: AnimationStartTime | null): void;
+    setToEnd(): void;
+    _dup(): TriggerAnimationStep;
+}
+export declare function trigger(triggerOrOptionsIn?: Function | OBJ_TriggerAnimationStep, ...optionsIn: Array<OBJ_TriggerAnimationStep>): TriggerAnimationStep;

package/types/js/figure/Animation/AnimationStep.d.ts

@@ -0,0 +1,110 @@
+import type { FigureElement } from '../Element';
+import { FunctionMap } from '../../tools/FunctionMap';
+import TimeKeeper from '../TimeKeeper';
+import type { AnimationStartTime } from './AnimationManager';
+/**
+ * Animation Step options object
+ *
+ * @property {number} [duration] in seconds (`0`)
+ * @property {number} [delay] delay before animation starts in seconds (`0`)
+ * @property {string} [name] animation name identifier (a random string)
+ * @property {null | (boolean) => void} [onFinish] called when animation is
+ * finished - a `true` parameter is passed to the callback if the animation was
+ * cancelled
+ * @property {boolean} [removeOnFinish] `true` to remove the animation from the
+ * animation manager when it is finished (`true`)
+ * @property {null | boolean} [completeOnCancel] `true` to skip to end of
+ * animation on cancel (`null`)
+ * @property {number} [precision] precision to do calculations to (`8`)
+ * @property {TimeKeepr} [timeKeeper] animations need to be tied to a time
+ * reference. If this is not supplied, then the default browser time reference
+ * performance.now will be used and methods with {@link TypeWhen} parameters
+ * will allow only `'now'` and `'nextFrame'` and not `'lastFrame'`, `'syncNow'`.
+ * When the animation step is created from an element in a figure (using
+ * `element.animations` or `element.animations.new()`), then the
+ * animation step will automatically inherit the figure's TimeKeeper.
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_AnimationStep = {
+    onFinish?: ((cancelled: boolean) => void) | null;
+    completeOnCancel?: boolean | null;
+    removeOnFinish?: boolean;
+    name?: string;
+    duration?: number;
+    delay?: number;
+    precision?: number;
+    timeKeeper?: TimeKeeper | null;
+};
+/**
+ * Animation step base class. All animation steps extend this class.
+ *
+ * @property {number} duration in seconds
+ * @property {number} startDelay delay before animation starts in seconds
+ * @property {string} name animation name identifier
+ * @property {null | (boolean) => void} [onFinish] called when animation is
+ * finished - a `true` parameter is passed to the callback if the animation was
+ * cancelled
+ * @property {null | boolean} [completeOnCancel] `true` to skip to end of
+ * animation on cancel
+ * @property {boolean} [removeOnFinish] `true` to remove the animation from the
+ * animation manager when it is finished (`true`)
+ * @property {number} [precision] precision to do calculations to (`8`)
+ * @property {'animating' | 'waitingToStart' | 'idle' | 'finished'} state
+ * @group Misc Animation
+ */
+export default class AnimationStep {
+    startTime: number | null | undefined;
+    duration: number;
+    onFinish: (string | ((cancelled: boolean) => void)) | null | undefined;
+    completeOnCancel: boolean | null | undefined;
+    state: 'animating' | 'waitingToStart' | 'idle' | 'finished';
+    startTimeOffset: number;
+    removeOnFinish: boolean;
+    name: string;
+    startDelay: number;
+    beforeFrame: ((percent: number) => void) | null | undefined;
+    afterFrame: ((percent: number) => void) | null | undefined;
+    _stepType: string;
+    fnMap: FunctionMap;
+    precision: number;
+    timeKeeper: TimeKeeper | null;
+    element: FigureElement | null | undefined;
+    constructor(optionsIn?: OBJ_AnimationStep);
+    _fromDef(definition: Record<string, any>, getElement?: ((name: string) => FigureElement) | null): this;
+    fnExec(idOrFn: string | Function | null, ...args: any): any;
+    setTimeDelta(delta: number | null | undefined): void;
+    _getStateProperties(): string[];
+    _getStateName(): string;
+    _state(options: Record<string, any>): {
+        f1Type: string;
+        state: Record<string, any>;
+    };
+    _fromState(state: Record<string, any>, getElement: ((name: string) => FigureElement) | null | undefined, timeKeeper: TimeKeeper): this;
+    setTimeSpeed(oldSpeed: number, newSpeed: number, now: number): void;
+    nextFrame(now: number, speed?: number): number | null;
+    /**
+     * Get remaining duration of the animation.
+     * @param {number} now define this if you want remaining duration from a
+     * custom time
+     */
+    getRemainingTime(now: number): number | null;
+    getTotalDuration(): number | null;
+    setFrame(deltaTime: number): void;
+    startWaiting(): void;
+    /**
+     * Start animation
+     * @param {AnimationStartTime} startTime
+     */
+    start(startTime?: AnimationStartTime | null): void;
+    finishIfZeroDuration(): void;
+    setToEnd(): void;
+    finish(cancelled?: boolean, force?: 'complete' | 'freeze' | null): void;
+    cancelledWithNoComplete(): void;
+    cancel(force?: 'complete' | 'freeze' | null): void;
+    _dup(): AnimationStep;
+    whenFinished(callback: string | ((cancelled: boolean) => void)): this;
+    ifCanceledThenComplete(): this;
+    ifCancelled(then?: 'complete' | 'freeze'): this;
+    ifCanceledThenStop(): this;
+}

package/types/js/figure/DrawContext2D.d.ts

@@ -0,0 +1,9 @@
+declare class DrawContext2D {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    ratio: number;
+    constructor(canvas: HTMLCanvasElement);
+    resize(): void;
+    _dup(): this;
+}
+export default DrawContext2D;

package/types/js/figure/DrawingObjects/DrawingObject.d.ts

@@ -0,0 +1,45 @@
+import { Point } from '../../tools/g2';
+import type { Type3DMatrix } from '../../tools/m3';
+import type Scene from '../../tools/geometry/scene';
+import type { TypeColor } from '../../tools/types';
+import type { CPY_Step } from '../geometries/copy/copy';
+import type WebGLInstance from '../webgl/webgl';
+/**
+ * Drawing Object
+ *
+ * Manages drawing an element to a WebGL or Context 2D canvas. Can also
+ * be used to manage a HTML element on the screen.
+ *
+ * @property {Array<Array<Point>>} border each array of points defines a
+ * closed boundary or border of the element. An element may have multiple
+ * closed borders. A border defines where a shape can be touched, or how it
+ * bounces of figure boundaries
+ * @see {@link FigureElementPrimitive}
+ * @group Misc Figure Element
+ */
+declare class DrawingObject {
+    location: Point;
+    border: Array<Array<Point>>;
+    textBorder: Array<Array<Point>>;
+    textBorderBuffer: Array<Array<Point>>;
+    type: string;
+    state: 'loading' | 'loaded';
+    constructor();
+    _dup(): this;
+    setText(textOrOptions: string | Record<string, any>, index?: number): void;
+    update(options: Record<string, any>): void;
+    getCanvas(): any;
+    drawWithTransformMatrix(scene: Scene, transformMatrix: Type3DMatrix, color: TypeColor, numPoints: number, targetTexture?: boolean): void;
+    getLocation(transformMatrix?: Type3DMatrix | null): Point;
+    getPointCountForAngle(): number;
+    updateVertices(vertices: Array<number>): void;
+    updateBuffer(name: string, data: Array<number>): void;
+    updateUniform(uniformName: string, value: number | Array<number>): void;
+    getUniform(uniformName: string): void;
+    cleanup(): void;
+    change(drawingPrimitive: any, copy?: Array<CPY_Step>): void;
+    _getStateProperties(): never[];
+    _state(options: Record<string, any>): Record<string, any>;
+    init(webgl: WebGLInstance): void;
+}
+export default DrawingObject;

package/types/js/figure/DrawingObjects/GLObject/GLObject.d.ts

@@ -0,0 +1,146 @@
+import Scene from '../../../tools/geometry/scene';
+import type { Type3DMatrix } from '../../../tools/m3';
+import WebGLInstance from '../../webgl/webgl';
+import type { TypeFragmentShader, TypeVertexShader } from '../../webgl/shaders';
+import { Rect } from '../../../tools/g2';
+import DrawingObject from '../DrawingObject';
+import type { TypeColor } from '../../../tools/types';
+/**
+ * `'BYTE' | 'UNSIGNED_BYTE' | 'SHORT' | 'UNSIGNED_SHORT' | 'FLOAT'`
+ * @group Shaders
+ */
+export type TypeGLBufferType = 'BYTE' | 'UNSIGNED_BYTE' | 'SHORT' | 'UNSIGNED_SHORT' | 'FLOAT';
+/**
+ * `'STATIC' | 'DYNAMIC'`
+ * @group Shaders
+ */
+export type TypeGLBufferUsage = 'STATIC' | 'DYNAMIC';
+/**
+ * `'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR'`
+ * @group Shaders
+ */
+export type TypeGLUniform = 'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR';
+/**
+ * FigureElementPrimitive that can be used to utilize custom shaders for WebGL.
+ *
+ * @group Misc Figure Element
+ */
+declare class GLObject extends DrawingObject {
+    gl: WebGLRenderingContext;
+    webgl: WebGLInstance;
+    glPrimitive: number;
+    z: number;
+    texture: {
+        id: string;
+        src?: string;
+        points: Array<number>;
+        buffer?: WebGLBuffer | null;
+        repeat?: boolean;
+        mapTo: Rect;
+        mapFrom: Rect;
+        data?: HTMLImageElement | null;
+        loadColor: TypeColor;
+        [key: string]: any;
+    } | null;
+    attributes: {
+        [attributeName: string]: {
+            buffer: WebGLBuffer | null;
+            size: number;
+            type: number;
+            normalize: boolean;
+            stride: number;
+            offset: number;
+            usage: number;
+            data: Array<number>;
+        };
+    };
+    points: Array<number>;
+    uniforms: {
+        [uniformName: string]: {
+            value: Array<number>;
+            method: (location: WebGLUniformLocation, name: string) => void;
+        };
+    };
+    numVertices: number;
+    state: 'loading' | 'loaded';
+    programIndex: number;
+    selectorProgramIndex: number;
+    onLoad: ((result: boolean, id: string) => void) | null | undefined;
+    vertexShader: TypeVertexShader;
+    fragmentShader: TypeFragmentShader;
+    selectorVertexShader: TypeVertexShader;
+    selectorFragmentShader: TypeFragmentShader;
+    constructor(webgl: WebGLInstance, vertexShader?: TypeVertexShader, fragmentShader?: TypeFragmentShader, selectorVertexShader?: TypeVertexShader, selectorFragShader?: TypeFragmentShader);
+    init(webgl: WebGLInstance): void;
+    initProgram(): void;
+    showShaders(): void;
+    showSelectorShaders(): void;
+    getCanvas(): HTMLCanvasElement | OffscreenCanvas;
+    setPrimitive(primitiveType: 'TRIANGLES' | 'POINTS' | 'TRIANGLE_FAN' | 'TRIANGLE_STRIP' | 'LINES' | 'LINE_LOOP' | 'LINE_STRIP' | 'FAN' | 'STRIP'): void;
+    initAttributes(): void;
+    setZ(z: number): void;
+    contextLost(): void;
+    updateTextureMap(points?: Array<number>): void;
+    /**
+     * Buffer a texture for the shape to be painted with.
+     */
+    addTexture(location: string, mapFrom?: Rect, mapTo?: Rect, mapToBuffer?: string, points?: Array<number>, repeat?: boolean, onLoad?: null | (() => void), loadColor?: TypeColor): void;
+    updateTexture(data: HTMLImageElement): void;
+    initTexture(force?: boolean): void;
+    createTextureMap(xMinGL?: number, xMaxGL?: number, yMinGL?: number, yMaxGL?: number, xMinTex?: number, xMaxTex?: number, yMinTex?: number, yMaxTex?: number): void;
+    addVertices(vertices: Array<number>, dimension?: 2 | 3, usage?: TypeGLBufferUsage): void;
+    addVertices3(vertices: Array<number>, usage?: TypeGLBufferUsage): void;
+    addNormals(normals: Array<number>, usage?: TypeGLBufferUsage): void;
+    addColors(colors: Array<number>, normalized?: boolean, usage?: TypeGLBufferUsage): void;
+    addAttribute(name: string, size: number, data: Array<number>, typeIn?: TypeGLBufferType, normalize?: boolean, stride?: number, offset?: number, usageIn?: TypeGLBufferUsage): void;
+    fillBuffer(name: string, data: Array<number>): void;
+    executeOnLoad(result: boolean, id: string): void;
+    resetTextureBuffer(deleteTexture?: boolean): void;
+    cleanup(deleteTexture?: boolean): void;
+    resetBuffers(deleteTexture?: boolean): void;
+    updateVertices(vertices: Array<number>): void;
+    updateVertices3(vertices: Array<number>): void;
+    updateAttribute(name: string, data: Array<number>): void;
+    _getStateProperties(): never[];
+    /**
+     * Get the current value of a uniform
+     */
+    getUniform(uniformName: string): number[];
+    /**
+     * Add a uniform.
+     *
+     * Length 16 corresponds to a 4x4 matrix and can only be
+     * `'FLOAT_VECTOR'` type.
+     *
+     * @param {string} uniformName The variable name used in the shader
+     * @param {1 | 2 | 3 | 4 | 16} length (`1`) number of values in uniform
+     * @param {'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR'} type type of
+     * value. Use '_VECTOR' suffix if using vector methods on the uniform in the
+     * shader (`'FLOAT'`).
+     * @param {number | Array<number> | null} initialValue initial value to use
+     * for uniform - if null then uniform will be all 0 (`null`)
+     */
+    addUniform(uniformName: string, length?: 1 | 2 | 3 | 4 | 16, type?: TypeGLUniform, initialValue?: number | Array<number> | null): void;
+    uploadUniform1f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform16fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4i(location: WebGLUniformLocation, name: string): void;
+    updateUniform(uniformName: string, value: number | Array<number>): void;
+    drawWithTransformMatrix(scene: Scene, worldMatrix: Type3DMatrix, color: TypeColor, numDrawVertices?: number, targetTexture?: boolean): void;
+    getPointCountForAngle(drawAngle?: number): number;
+    getPointCountForLength(drawLength: number): number;
+}
+export default GLObject;

package/types/js/figure/DrawingObjects/HTMLObject/HTMLObject.d.ts

@@ -0,0 +1,29 @@
+import { Point } from '../../../tools/g2';
+import DrawingObject from '../DrawingObject';
+import type { TypeColor } from '../../../tools/types';
+import type { Type3DMatrix } from '../../../tools/m3';
+import type Scene from '../../../tools/geometry/scene';
+declare class HTMLObject extends DrawingObject {
+    border: Array<Array<Point>>;
+    id: string;
+    location: Point;
+    element: HTMLElement;
+    parentDiv: HTMLElement;
+    xAlign: 'left' | 'right' | 'center';
+    yAlign: 'top' | 'bottom' | 'middle';
+    show: boolean;
+    lastMatrix: Array<number>;
+    lastColor: Array<number>;
+    forceDraw: boolean;
+    originalElement: HTMLElement;
+    copy: () => HTMLObject;
+    constructor(parentDiv: HTMLElement, id: string, location: Point, yAlign: "top" | "bottom" | "middle" | undefined, xAlign: "left" | "right" | "center" | undefined, originalElement: HTMLElement | Array<HTMLElement>);
+    _dup(): any;
+    setBorder(): void;
+    getBoundaries(): Array<Array<Point>>;
+    glToPixelSpace(p: Point): Point;
+    change(newHtml: any, lastDrawTransformMatrix?: any): void;
+    transformHtml(transformMatrix: Type3DMatrix, opacity?: number): void;
+    drawWithTransformMatrix(scene: Scene, worldMatrix: Type3DMatrix, color: TypeColor): void;
+}
+export default HTMLObject;