figureone 0.15.10 → 1.0.0

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

@@ -0,0 +1,174 @@
+/**
+ * `'nextFrame'` | `'prevFrame'` | `'syncNow'` | `'now'`
+ *
+ *
+ * `'syncNow'` is a synchronized 'now' time. The
+ * first time 'syncNow' is used, the current time will be stored and used
+ * for all subsequent calls to 'syncNow'. 'syncNow' is reset every
+ * time a new animation frame is drawn, or 100ms after a first syncNow call
+ * has been made after a reset.
+ *
+ * 'now' is the instantaneous time
+ *
+ * `'nextFrame'` will be the time of the next animation frame
+ *
+ * `'prevFrame'` is the time of the last animation frame
+ * @typedef {'now' | 'nextFrame' | 'prevFrame' | 'syncNow'} TypeWhen
+ * @group Misc Animation
+ */
+export type TypeWhen = 'now' | 'nextFrame' | 'prevFrame' | 'syncNow';
+/**
+ * TimeKeeper keeps time for a figure, where time is the number of
+ * milliseconds after the page is loaded.
+ *
+ * Time can be real time, sped up, slowed down or manually stepped.
+ *
+ * The current time can be accessed using the `now` method.
+ *
+ * In it's default form, `now` is the same as the system time
+ * `performance.now()` or the animation time sent through on frames requested
+ * from `requestAnimationFrame` .
+ *
+ * However, these system times diverge from `now` when TimeKeeper's time
+ * speed is changed, or manual time deltas are enabled.
+ *
+ * When time speed is n times faster than real time, `now` will report n times
+ * more passage of time from the page load than real time. So if the speed is
+ * set to 2, then `now` will report time passing twice as fast.
+ *
+ * If timeouts are needed in a figure's logic, use `figure.timeKeeper.
+ * setTimeout` and `figure.timeKeeper.clearTimeout` methods instead of the
+ * system equivalents so the timeouts follow figure time.
+ *
+ * TimeKeeper can also be used to synchronize times (for example, for multiple
+ * animations being started where it is desired they all have precisely the
+ * same start time). See `getWhen` method for information on how to retrieve a
+ * synchronized time
+ * @group Misc Figure Element
+ */
+declare class TimeKeeper {
+    requestNextAnimationFrame: (callback: FrameRequestCallback) => number;
+    animationId: number | null;
+    static instance: TimeKeeper;
+    drawQueue: Array<(time: number) => void>;
+    nextDrawQueue: Array<(time: number) => void>;
+    lastDrawTime: number | null;
+    nowTime: number;
+    timeoutId: ReturnType<typeof setTimeout> | null;
+    speed: number;
+    synchronizedNow: number;
+    updateSyncNow: boolean;
+    syncNowTimer: number;
+    manual: boolean;
+    animateOnFrame: boolean;
+    lastTime: number;
+    idCounter: number;
+    syncNowTimeout: number;
+    timers: {
+        [id: string]: {
+            id: ReturnType<typeof setTimeout> | null;
+            callback: () => void;
+            timeout: number;
+            description: string;
+            stateTimer: boolean;
+        };
+    };
+    constructor();
+    /**
+     * Reset TimeKeeper to 0 time.
+     *
+     * All ongoing timers will be cancelled, and all properties reset.
+     */
+    reset(): void;
+    clearTimeouts(): void;
+    /**
+     * Current relative time now, of most recent animation frame or of most
+     * recent synchronized time.
+     *
+     */
+    getWhen(when: TypeWhen): number | null;
+    /**
+     * Get synchronized relative now time.
+     *
+     * Each call of `now` when not using manual frames will result in a
+     * progressed time value in ms from the page load.
+     *
+     * This can be a challenge if you want to start two animations at precisely
+     * the same time.
+     *
+     * When syncNow is first called, the actual now time is returned. Each
+     * subsequent call of syncNow will return the same number. syncNow is reset
+     * on each animation frame, or after `TimeKeeper.syncNowTimeout` is ellapsed
+     * (defaults to 100ms).
+     */
+    syncNow(): number;
+    updateNow(): void;
+    /**
+     * Current relative time.
+     *
+     * If speed is 1 and manual frames have not been used, then this will return
+     * the time in ms after the page is loaded.
+     *
+     * If speed is not 1, or manual frames have been or are being used, then this
+     * will return the relative time in ms taking into account pauses and frame
+     * steps from any manual frames, and any speed changes.
+     *
+     * @param {number} time in ms from page load
+     */
+    now(): number;
+    /**
+     * Set the speed of time. 1 is normal timer, >1 is faster than normal time
+     * and <1 is slower than normal time. The speed must be greater than 0.
+     *
+     * @param {number} speedFactor
+     */
+    setSpeed(speedFactor?: number): void;
+    /**
+     * Set manual frames.
+     * When set, all animation frames can only be initiated with `frame`.
+     */
+    setManualFrames(): void;
+    /**
+     * End manual frames.
+     * When ended, animation frames will again be triggered by
+     * requestAnimationFrame from the browser.
+     */
+    endManualFrames(): void;
+    /**
+     * Step manual frames by a delta time in seconds.
+     * @param {number} timeStepInSeconds
+     */
+    frame(timeStepInSeconds: number): void;
+    incrementTimers(targetTime: number): number;
+    /**
+     * Use like normal setTimeout in javascript.
+     *
+     * @param {function(): void} callback function to be called after some time
+     * @param {number} time in ms
+     * @param {string} description timer description useful for debugging but not
+     * requied ('')
+     * @param {boolean} stateTime internal use only
+     *
+     * @return {number} unique identifier that can be used to clear timer with
+     * `clearTimeout`
+     */
+    setTimeout(callback: () => void, time: number, description?: string, stateTimer?: boolean): number;
+    /**
+     * Clear a current timer (the callback will not be called).
+     *
+     * @param {number | null} id timer identifier return from `setTimeout`. If
+     * null, no action occurs.
+     */
+    clearTimeout(id: number | null): void;
+    draw(): void;
+    /**
+     * Queue function to be called the next time an animation frame is triggered
+     *
+     * @param {function(number): void} func function that will be passed the
+     * current time as an input parameter when it is called
+     */
+    queueNextFrame(func: (time: number | null) => void): void;
+    animateNextFrame(): void;
+    _dup(): this;
+}
+export default TimeKeeper;

package/types/js/figure/geometries/arc.d.ts

@@ -0,0 +1,18 @@
+import { Point } from '../../tools/g2';
+import type { OBJ_Generic } from '../FigurePrimitives/FigurePrimitiveTypes2D';
+export type OBJ_Arc_Defined = {
+    radius: number;
+    sides: number;
+    startAngle: number;
+    angle: number;
+    line?: {
+        widthIs: 'inside' | 'outside' | 'positive' | 'negative' | 'mid';
+        width: number;
+    };
+    offset: Point;
+    fillCenter: boolean;
+    drawBorderBuffer: number | Array<Array<Point>>;
+} & OBJ_Generic;
+declare function getArcBorder(options: OBJ_Arc_Defined): Array<Point>;
+declare function arcBorderToTris(border: Array<Point>): Point[];
+export { getArcBorder, arcBorderToTris, };

package/types/js/figure/geometries/arrow.d.ts

@@ -0,0 +1,215 @@
+import { Point } from '../../tools/g2';
+import type { OBJ_Arrow } from '../FigurePrimitives/FigurePrimitiveTypes2D';
+/**
+ * Arrow heads
+ *
+ * `'triangle' | 'circle' | 'line' | 'barb' | 'bar' | 'polygon' | 'rectangle'`
+ *
+ * @see {@link OBJ_Arrow} for properties related to each arrow head
+ */
+export type TypeArrowHead = 'triangle' | 'circle' | 'line' | 'barb' | 'bar' | 'polygon' | 'reverseTriangle' | 'rectangle';
+/**
+ * Arrow end for a line or polyline.
+ *
+ * ![](./apiassets/arrow_line.png)
+ *
+ * Arrows on the end of lines have many of the same properties as stand
+ * alone arrows {@link OBJ_Arrow}.
+ *
+ * The `align` property descripes where the line stops relative to the arrow.
+ * `'start'` will be most useful for pointed arrows. When there is no tail, or
+ * a zero length tail, `'mid'` can be useful with '`polygon`', '`circle`' and
+ * '`bar`' as then the shapes will be centered on the end of the line. Note
+ * that in this case the shape will extend past the line.
+ *
+ * @property {TypeArrowHead} [head] head style (`'triangle'`)
+ * @property {number} [scale] scale the default dimensions of the arrow
+ * @property {number} [length] dimension of the arrow head along the line
+ * @property {number} [width] dimension of the arrow head along the line width
+ * @property {number} [rotation] rotation of the polygon when `head = 'polygon'`
+ * @property {number} [sides] number of sides in polygon or circle arrow head
+ * @property {number} [radius] radius of polygon or circle arrow head
+ * @property {number} [barb] barb length (along the length of the line) of the
+ * barb arrow head
+ * @property {boolean | number} [tail] `true` includes a tail in the arrow of
+ * with `tailWidth`. A `number` gives the tail a length where 0 will not
+ * extend the tail beyond the boundaries of the head
+ * @property {'start' | 'mid'} [align] define which part of
+ * the arrow is aligned at (0, 0) in draw space (`'start'`)
+ *
+ * @interface
+ * @group Misc Shapes
+ * @example
+ * // Line with triangle arrows on both ends
+ * figure.add({
+ *   name: 'a',
+ *   make: 'polyline',
+ *   points: [[0, 0], [1, 0]],
+ *   width: 0.02,
+ *   arrow: 'triangle',
+ * });
+ *
+ * @example
+ * // Line with customized barb arrow at end only
+ * figure.add({
+ *   name: 'a',
+ *   make: 'shapes.line',
+ *   p1: [0, 0],
+ *   p2: [0, 1],
+ *   width: 0.02,
+ *   arrow: {
+ *     end: {
+ *       head: 'barb',
+ *       width: 0.15,
+ *       length: 0.25,
+ *       barb: 0.05,
+ *       scale: 2
+ *     },
+ *   },
+ *   dash: [0.02, 0.02],
+ * });
+ *
+ * @example
+ * // Three lines showing the difference between mid align and start align for
+ * // circle heads
+ * figure.add([
+ *   {
+ *     name: 'reference',
+ *     make: 'polyline',
+ *     points: [[0, 0.3], [0.5, 0.3]],
+ *   },
+ *   {
+ *     name: 'start',
+ *     make: 'polyline',
+ *     points: [[0, 0], [0.5, 0]],
+ *     arrow: {
+ *       head: 'circle',
+ *       radius: 0.1,
+ *     },
+ *   },
+ *   {
+ *     name: 'mid',
+ *     make: 'polyline',
+ *     points: [[0, -0.3], [0.5, -0.3]],
+ *     arrow: {
+ *       head: 'circle',
+ *       radius: 0.1,
+ *       align: 'mid',     // circle mid point is at line end
+ *     },
+ *   },
+ * ]);
+ */
+export type OBJ_LineArrow = {
+    head?: TypeArrowHead;
+    scale?: number;
+    length?: number;
+    width?: number;
+    rotation?: number;
+    sides?: number;
+    radius?: number;
+    barb?: number;
+    tail?: boolean;
+    align?: 'start' | 'mid';
+};
+/**
+ * Line end's arrow definition options object.
+ *
+ * `start` and `end` define the properties of the arrows at the start and
+ * end of the line. Instead of defining {@link OBJ_LineArrow} objects for the
+ * start and end, a string that is the arrow's `head` property can also be
+ * used and the size dimensions will be the default.
+ *
+ * All other properties will be used as the default for the `start` and
+ * `end` objects.
+ *
+ * If any of the default properties are defined, then the line will have
+ * both a start and end arrow.
+ *
+ * If only one end of the line is to have an arrow, then define only the
+ * `start` or `end` properties and no others.
+ *
+ * @property {OBJ_LineArrow | TypeArrowHead} [start] arrow at start of line
+ * @property {OBJ_LineArrow | TypeArrowHead} [end] arrow at end of line
+ * @property {TypeArrowHead} [head] default head to use for start and end arrow
+ * @property {number} [scale] default scale to use for start and end arrow
+ * @property {number} [length] default length to use for start and end arrow
+ * @property {number} [width] default width to use for start and end arrow
+ * @property {number} [rotation] default rotation to use for start and end arrow
+ * @property {number} [sides] default sides to use for start and end arrow
+ * @property {number} [radius] default radius to use for start and end arrow
+ * @property {number} [barb] default barb to use for start and end arrow
+ * @property {number} [tailWidth] width of the line that joins the arrow - if
+ * defined this will create minimum dimensions for the arrow
+ * @property {boolean | number} [tail] `true` includes a tail in the arrow of
+ * with `tailWidth`. A `number` gives the tail a length where 0 will not
+ * extend the tail beyond the boundaries of the head
+ * @property {'start' | 'mid'} [align] define which part of
+ * the arrow is aligned at (0, 0) in draw space (`'start'`)
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_LineArrows = {
+    start: OBJ_LineArrow | TypeArrowHead;
+    end: OBJ_LineArrow | TypeArrowHead;
+    head?: TypeArrowHead;
+    scale?: number;
+    length?: number;
+    width?: number;
+    rotation?: number;
+    sides?: number;
+    radius?: number;
+    barb?: number;
+    tailWidth?: number;
+    tail?: boolean | number;
+    align?: 'start' | 'mid';
+};
+declare function getTriangleArrow(options: {
+    length: number;
+    width: number;
+    tailWidth: number;
+    drawBorderBuffer: number;
+    tail: boolean | number;
+    lineWidth: number;
+}): Point[][];
+declare function getBarbArrow(options: {
+    length: number;
+    width: number;
+    barb: number;
+    drawBorderBuffer: number;
+    tailWidth: number;
+    tail: boolean | number;
+}): Point[][];
+declare function getArrowLength(options: {
+    head: TypeArrowHead;
+    length: number;
+    tailWidth: number;
+    width: number;
+    radius: number;
+    align: 'mid' | 'start';
+    tail: number | boolean;
+    barb: number;
+}): number[];
+declare function getArrow(options: {
+    head: TypeArrowHead;
+    length: number;
+    width: number;
+    barb: number;
+    start: Point;
+    end: Point;
+    drawBorderBuffer: number;
+    tailWidth: number;
+    radius: number;
+    rotation: number;
+    sides: number;
+    reverse: boolean;
+    tail: number | boolean;
+}): [Point[], Point[][], Point[]];
+declare function getArrowTris(border: Array<Point>, options: {
+    head: TypeArrowHead;
+}): Point[];
+declare function defaultArrowOptions(o: Record<string, any>): any;
+declare function simplifyArrowOptions(arrowIn: null | TypeArrowHead | {
+    start: OBJ_Arrow | TypeArrowHead;
+    end: OBJ_Arrow | TypeArrowHead;
+} & OBJ_Arrow, tailWidth: number | null, includeTailByDefault?: boolean): Record<string, any> | undefined;
+export { getTriangleArrow, getBarbArrow, getArrow, getArrowLength, simplifyArrowOptions, defaultArrowOptions, getArrowTris, };

package/types/js/figure/geometries/buffer.d.ts

@@ -0,0 +1,4 @@
+import { Point } from '../../tools/g2';
+declare function getBufferBorder(bordersIn: Array<Array<Point>>, buffer: number, skipConcave?: boolean, bufferOffset?: 'positive' | 'negative'): Point[][];
+export { // eslint-disable-next-line import/prefer-default-export
+getBufferBorder, };

package/types/js/figure/geometries/copy/copy.d.ts

@@ -0,0 +1,178 @@
+import { Point } from '../../../tools/g2';
+import type { TypeParsablePoint, TypeParsableTransform } from '../../../tools/g2';
+/**
+ *
+ * ![](./apiassets/copy.png)
+ *
+ * Copy Step options object
+ *
+ * A copy step defines how to copy existing points.
+ *
+ * An array of copy steps will cumulatively copy points from an original set of
+ * points.
+ *
+ * So, if there are two copy steps then:
+ * - the first step will copy the original points
+ * - the second step will copy the original points and the first copy of the
+ *   points
+ *
+ * For example, a grid of a shape can be made with two copy steps. The first
+ * replicates the shape along the x axis, creating a line of shapes. The second
+ * copy step then replicates the line of shapes in the y axis, creating a grid
+ * of shapes.
+ *
+ * Each copy step appends its copied points onto an array of points that
+ * started with the original points. By default, copy steps operate on all
+ * points created in previous steps. However, the properties `start` and `end`
+ * can be used to make the current step only operate on a subset of the points.
+ *
+ * `start` and `end` refer to the indexes of the copy steps where the original
+ * points is at index 0, and the first copy step is at index 1. Copy step
+ * arrays can also include *marker strings* which make defining `start` and
+ * `end` more convient (see the third example below). These marker strings
+ * can be used as `start` and `end` values. Marker strings are included
+ * in the copy step indexing.
+ *
+ * There are two main ways to make a copy, either copy the points `to` a
+ * location, or copy the points `along` a path.
+ *
+ * When using the `to` property, if a {@link Point} is defined
+ * then the points will be copied to that point. If a {@link Transform} is
+ * defined, then a copy of the points will be transformed by that transform. An
+ * array of points and transforms can be defined to make multiple copies of the
+ * points.
+ *
+ * When using the `along` property, the points are copied a number (`num`) of
+ * times along a path with some `step`. The paths can be horiztonal (`'x'`),
+ * vertical (`'y'`), along the z axis (`'z'`), at an angle in the xy plane,
+ * (`number`), along a direction vector (`TypeParsablePoint`) or through a
+ * `'rotation'` around a `center` point and `axis`.
+ *
+ * When copying along a line (`along` is `'x'`, `y'`, `'z'`,
+ * `TypeParsablePoint` or a `number`), then `step` will be the distance offset
+ * along the line.
+ *
+ * When copying along a rotation (`along` is `'rotation'`), then `step` will be
+ * the angular step in radians.
+ *
+ * Any step can use the `original` property - but it will only operate on the
+ * last step that uses it. When `original` is `false`, then all points before
+ * that copy step will not be included in the returned Point array.
+ *
+ * @property {TypeParsablePoint | TypeParsableTransform | Array<TypeParsablePoint | TypeParsableTransform>} [to] copy points to
+ * a location or locations or transform a copy of the points
+ * @property {'x' | 'y' | number | 'rotation' | 'moveOnly' | TypeParsablePoint} [along]
+ * copy points along a linear path where `number` is a path at an angle in
+ * radians in the xy plane, and `TypeParsablePoint` is a direction vector
+ * @property {TypeParsablePoint} [axis] axis to rotate a 'rotation' copy around
+ * (default is the z axis so rotation is in xy plane `[0, 0, 1]`)
+ * @property {number} [num] the number of copies to make when copying `along` a
+ * path
+ * @property {number} [step] distance between copies if `along` is `'x'` or
+ * `'y'` or a `number`, delta angle between copies if `along` is `'rotation'`
+ * @property {TypeParsablePoint} [center] the center point about which to rotate
+ * the copies when using `along` = `'rotation'`
+ * @property {number | string} [start] copy step index or marker defining the
+ * start of the points to copy
+ * @property {number | string} [end] copy step index or marker defining the end
+ * of the points to copy
+ * @property {boolean} [original] `false` excludes all points before this step
+ * in the final result (`true`)
+ * @example
+ * // Grid copy
+ * figure.add({
+ *   name: 'triGrid',
+ *   make: 'polygon',
+ *   radius: 0.1,
+ *   sides: 3,
+ *   rotation: -Math.PI / 6,
+ *   fill: 'tris',
+ *   copy: [
+ *     {
+ *       along: 'x',
+ *       num: 4,
+ *       step: 0.3,
+ *     },
+ *     {
+ *       along: 'y',
+ *       num: 4,
+ *       step: 0.3,
+ *     },
+ *   ],
+ * });
+ *
+ * @example
+ * // Radial lines copy
+ * figure.add({
+ *   name: 'radialLines',
+ *   make: 'generic',
+ *   points: [
+ *     [-0.2, -0.1], [-0.2, 0.1], [0.2, 0.1],
+ *     [-0.2, -0.1], [0.2, 0.1], [0.2, -0.1],
+ *   ],
+ *   copy: [
+ *     {
+ *       to: [[0.6, 0], [1.05, 0], [1.5, 0], [2.2, 0]],
+ *     },
+ *     {
+ *       along: 'rotation',
+ *       num: 5,
+ *       step: Math.PI / 5,
+ *       start: 1,              // only copy last step, not original points
+ *     },
+ *   ],
+ * });
+ *
+ * @example
+ * // Ring copy (without original shape)
+ * figure.add({
+ *   name: 'halfRings',
+ *   make: 'polygon',
+ *   radius: 0.1,
+ *   sides: 20,
+ *   fill: 'tris',
+ *   copy: [
+ *     'ring1',               // marker 1
+ *     {
+ *       to: [0.5, 0],
+ *       original: false,     // don't include the original shape
+ *     },
+ *     {
+ *       along: 'rotation',
+ *       num: 7,
+ *       step: Math.PI / 7,
+ *       start: 'ring1',      // copy only from marker 1
+ *     },
+ *     'ring2',               // marker 2
+ *     {
+ *       to: [1, 0],
+ *       start: 0,            // make a copy of the original shape only
+ *       end: 1,
+ *     },
+ *     {
+ *       along: 'rotation',
+ *       num: 15,
+ *       step: Math.PI / 15,
+ *       start: 'ring2',      // copy points from Marker 2 only
+ *     },
+ *   ],
+ * });
+ * @interface
+ * @group Misc Shapes
+ */
+export type CPY_Step = {
+    to?: TypeParsablePoint | TypeParsableTransform | Array<TypeParsablePoint | TypeParsableTransform>;
+    along?: 'x' | 'y' | 'z' | number | 'rotation' | 'moveOnly' | TypeParsablePoint;
+    axis?: TypeParsablePoint;
+    num?: number;
+    step?: number;
+    center?: TypeParsablePoint;
+    start?: number | string;
+    end?: number | string;
+    original?: boolean;
+};
+export type CPY_Steps = Array<CPY_Step>;
+declare function copyStep(points: Array<Point>, copyStyle: 'linear' | 'to' | 'rotation' | 'x' | 'y' | 'z' | number | TypeParsablePoint, options: CPY_Step, type?: 'points' | 'normals'): Point[];
+declare function copyPoints(points: Array<TypeParsablePoint> | Array<Point>, chain: CPY_Step | CPY_Steps | null | undefined, type?: 'points' | 'normals'): Array<Point>;
+declare function getCopyCount(chain: CPY_Step | CPY_Steps | null | undefined): number;
+export { copyPoints, copyStep, getCopyCount, };

package/types/js/figure/geometries/ellipse.d.ts

@@ -0,0 +1,17 @@
+import { Point } from '../../tools/g2';
+import type { OBJ_Generic } from '../FigurePrimitives/FigurePrimitiveTypes2D';
+export type OBJ_Ellipse_Defined = {
+    width: number;
+    height: number;
+    xAlign: 'left' | 'center' | 'right' | number;
+    yAlign: 'bottom' | 'middle' | 'top' | number;
+    sides: number;
+    line?: {
+        widthIs: 'inside' | 'outside' | 'positive' | 'negative' | 'mid';
+        width: number;
+    };
+    drawBorderBuffer: number | Array<Array<Point>>;
+} & OBJ_Generic;
+declare function getEllipseBorder(options: OBJ_Ellipse_Defined): Point[];
+declare function ellipseBorderToTris(border: Array<Point>): Point[];
+export { getEllipseBorder, ellipseBorderToTris, };

package/types/js/figure/geometries/line.d.ts

@@ -0,0 +1,13 @@
+import { Point } from '../../tools/g2';
+import type { TypeParsablePoint } from '../../tools/g2';
+declare function getLine(options: {
+    p1: Point;
+    p2?: Point;
+    length: number;
+    width: number;
+    angle: number;
+    widthIs: 'mid' | 'positive' | 'negative';
+    border: 'rect' | 'outline' | Array<Array<TypeParsablePoint>>;
+    touchBorder: 'rect' | 'border' | number | Array<Array<TypeParsablePoint>>;
+}): (Point[] | "line" | "rect" | TypeParsablePoint[][] | "outline" | "border")[];
+export default getLine;

package/types/js/figure/geometries/lines/corners.d.ts

@@ -0,0 +1,7 @@
+import { Point } from '../../../tools/g2';
+declare function circleCorner(p2in: Point, p1: Point, p3in: Point, sides: number): Array<Point>;
+declare function cutCorner(p2: Point, p1: Point, p3: Point, sides: number, style: 'radius' | 'fromVertex' | 'max', value: number): Array<Point>;
+declare function cornerLine(pointsIn: Array<Point>, close: boolean, type: 'fromVertex' | 'radius', sides: number, size: number): Point[];
+declare function makeCorner(p2: Point, p1: Point, p3: Point, length: number, forceLength?: boolean): Point[];
+declare function lineToCorners(pointsIn: Array<Point>, close: boolean, length: number, forceLength?: boolean): Point[][];
+export { circleCorner, cutCorner, cornerLine, makeCorner, lineToCorners, };

package/types/js/figure/geometries/lines/dashes.d.ts

@@ -0,0 +1,23 @@
+import { Point } from '../../../tools/g2';
+import type { TypeDash } from '../../../tools/types';
+declare function makeDashDefinition(dashes: Array<number>): {
+    definition: number[];
+    sum: number;
+    cum: number[];
+};
+declare function getDashElementAndRemainder(dash: {
+    definition: Array<number>;
+    cum: Array<number>;
+    sum: number;
+}, offset: number, precision?: number): number[];
+declare function makeDashes(dash: {
+    definition: Array<number>;
+    cum: Array<number>;
+    sum: number;
+}, p1: Point, p2: Point, offset: number, precision?: number): {
+    points: Point[][];
+    continues: boolean;
+    onLine: boolean;
+};
+declare function lineToDash(points: Array<Point>, dash: TypeDash, close?: boolean, precision?: number): (boolean | Point[][])[];
+export { getDashElementAndRemainder, makeDashDefinition, makeDashes, lineToDash, };