jsxgraph 1.4.2 → 1.4.5

package/distrib/index.d.ts

@@ -14,21 +14,31 @@
 //
 
 /**
- * JXG namespace.
+ * JSXGraph in the namespace JXG.
  */
-declare module JXG {
+declare namespace JXG {
+
   /**
-   *
+   * Store a reference to every board in this central list.
+   * This will at some point replace JXG.JSXGraph.boards.
    */
-  export type CoordType = 1 | 2
+  export const boards: unknown;
+
   /**
-   * User coordinates relative to the coordinates system defined by the bounding box.
+   *
    */
-  export const COORDS_BY_USER: 0x0001;
+  export type CoordType = 1 | 2
+
   /**
    * Screen coordinates in pixel relative to the upper left corner of the div element.
    */
   export const COORDS_BY_SCREEN: 0x0002;
+
+  /**
+   * User coordinates relative to the coordinates system defined by the bounding box.
+   */
+  export const COORDS_BY_USER: 0x0001;
+
   /**
    * A composition is a simple container that manages none or more GeometryElements.
    */
@@ -147,6 +157,11 @@ declare module JXG {
     isReal(): boolean;
   }
 
+  /**
+   * Associative array that keeps track of all constructable elements registered via JXG.registerElement.
+   */
+  export const elements: { [elementType: string]: unknown };
+
   /**
    * A JessieCode object provides an interface to the parser and stores all variables and objects used within a JessieCode script.
    * The optional argument code is interpreted after initializing.
@@ -235,6 +250,12 @@ declare module JXG {
   export function cloneAndCopy<S extends object, T extends object>(obj: S, obj2: T): S | T;
   export function cmpArrays(a1: unknown[], a2: unknown[]): boolean;
   export function coordsArrayToMatrix(coords: unknown[], split: boolean): unknown[];
+  /**
+   * Generates an attributes object that is filled with default values from the Options object and overwritten by the user specified attributes.
+   * @param attributes user specified attributes
+   * @param options defaults options
+   * @param s variable number of strings, e.g. 'slider', subtype 'point1'.
+   */
   export function copyAttributes<T>(attributes: T, options: JXGSettings, ...s: string[]): T;
   export function createEvalFunction<T>(board: Board, param: T[], n: number): (k: number) => T;
   export function createFunction(term: string | number | Function, board: Board, variableName: string, evalGeonext?: boolean): Function;
@@ -285,6 +306,22 @@ declare module JXG {
   export function escapeHTML(str: string): string;
   export function evalSlider(s: unknown): number;
   export function evaluate(val: unknown): unknown;
+  /**
+   * Checks if a given variable is neither undefined nor null. You should not use this together with global variables!
+   * @param v A variable of any type.
+   * @param checkEmptyString If set to true, it is also checked whether v is not equal to ''. Default: false.
+   * @returns True, if v is neither undefined nor null.
+   */
+  export function exists(v: unknown, checkEmptyString?: boolean): boolean;
+  /**
+   * Copy all properties of the extension object to object.
+   * @param obj
+   * @param extension
+   * @param onlyOwn Only consider properties that belong to extension itself, not any inherited properties. Default: false.
+   * @param toLower If true the keys are convert to lower case. This is needed for visProp, see JXG#copyAttributes. Default: false.
+   */
+  export function extend(obj: object, extension: object, onlyOwn?: boolean, toLower?: boolean): void;
+  export function extendConstants(obj: object, constants: object, onlyOwn?: boolean, toUpper?: boolean): void;
   export function filterElements<T>(list: T[], filter: object | Function): T[];
   export function getBoardByContainerId(s: string): Board | null;
   export function getCSSTrasform(cPos: number[], obj: Element): number[];
@@ -330,7 +367,12 @@ declare module JXG {
   export function merge<U, V>(obj1: U, obj2: V): U | V;
   export function normalizePointFace(s: string): 'x' | 'o' | '[]' | '+' | '<>' | '^' | 'v' | '<' | '>';
   export function providePoints(board: Board, parents: unknown[], attrClass: string, attrArray: unknown[]): JXG.Point[] | false;
-  export function registerElement(element: string, creator: Function): void;
+  /**
+   * This registers a new construction element to JSXGraph for the construction via the JXG.Board.create interface.
+   * @param element The elements name. This is case-insensitive, existing elements with the same name will be overwritten.
+   * @param creator The factory function that creates the GeometryElement.
+   */
+  export function registerElement(element: string, creator: ((board: Board, parents: unknown[], attributes: Record<string, unknown>) => GeometryElement | Composition | Array<GeometryElement>)): void;
   export function registerReader(reader: Function, ext: unknown[]): void;
   export function removeAllEvents(obj: unknown, type: string, owner: unknown): void;
   export function removeElementFromArray<T>(ar: T[], el: T): T;
@@ -412,16 +454,34 @@ declare module JXG {
      */
     name: string;
 
+    /**
+     * Controls if updates are necessary.
+     */
     needsUpdate: boolean;
 
+    /**
+     * Stores all Intersection Objects which in this moment are not real and so hide this element.
+     */
     notExistingParents: unknown;
 
+    /**
+     * Counts the number of objects drawn as part of the trace of the element.
+     */
     numTraces: number;
 
-    parents: unknown;
+    /**
+     * Ids of elements on which this element depends directly are stored here.
+     */
+    parents: string[];
 
+    /**
+     * Quadratic form representation of circles (and conics)
+     */
     quadraticform: unknown[];
 
+    /**
+     * Stores the SVG (or VML) rendering node for the element.
+     */
     rendNode: HTMLElement;
 
     /**
@@ -429,18 +489,41 @@ declare module JXG {
      */
     stdform: [C: number, A: number, B: number];
 
+    /**
+     * Subs contains the subelements, created during the create method.
+     */
     subs: unknown;
 
+    /**
+     * Stores variables for symbolic computations.
+     */
     symbolic: unknown;
 
+    /**
+     * Keeps track of all objects drawn as part of the trace of the element.
+     */
     traces: unknown;
 
+    /**
+     * Stores the transformations which are applied during update in an array
+     */
     transformations: unknown[];
 
+    /**
+     * Type of the element.
+     */
     type: number;
 
+    /**
+     * An associative array containing all visual properties.
+     */
     visProp: { [name: string]: unknown };
 
+    /**
+     * An associative array containing visual properties which are calculated from the attribute values (i.e. visProp) and from other constraints.
+     * An example: if an intersection point does not have real coordinates, visPropCalc.visible is set to false.
+     * Additionally, the user can control visibility with the attribute "visible", even by supplying a functions as value.
+     */
     visPropCalc: { [name: string]: unknown };
 
     /**
@@ -474,6 +557,12 @@ declare module JXG {
      */
     addRotation(angle: number): void;
 
+    /**
+     * Get the value of the property key.
+     * @param key The name of the property you are looking for.
+     */
+    getAttribute(key: string): any;
+
     /**
      * Returns the element name.
      */
@@ -493,14 +582,24 @@ declare module JXG {
      */
     hideElement(): void;
 
+    /**
+     * Unregister an event handler.
+     * For a list of possible events see documentation of the elements and objects implementing the EventEmitter interface.
+     * @param event
+     * @param handler
+     * @returns Reference to the object.
+     */
+    off(event: string, handler?: (e: Event) => void): this;
+
     /**
      * Register a new event handler.
      * For a list of possible events see documentation of the elements and objects implementing the EventEmitter interface.
      * @param event
      * @param handler
      * @param context The context the handler will be called in, default is the element itself.
+     * @returns Reference to the object.
      */
-    on(event: string, handler: (e: Event) => void, context?: unknown): void;
+    on(event: string, handler: (e: Event) => void, context?: unknown): this;
 
     /**
      * Sets an arbitrary number of attributes.
@@ -1494,11 +1593,11 @@ declare module JXG {
   }
 
   /**
-   *
+   * In this class all group management is done.
    */
   export class Group extends GeometryElement {
     /**
-     *
+     * Creates a new instance of Group.
      * @param board
      * @param id Unique identifier for this object. If null or an empty string is given, an unique id will be generated by Board.
      * @param name Not necessarily unique name, displayed on the board. If null or an empty string is given, an unique name will be generated.
@@ -1580,7 +1679,7 @@ declare module JXG {
      * Sets the rotation points of the group. Dragging at one of these points results into a rotation of the whole group around the rotation center of the group {@see JXG.Group#setRotationCenter}.
      * @param objects
      */
-    setRotationPoints(objects: Point[]): this;
+    setRotationPoints(objects: Point | Point[]): this;
     /**
      * Sets the center of scaling for the group. This is either a point or the centroid of the group.
      * @param object
@@ -1591,12 +1690,12 @@ declare module JXG {
      * @param objects Array of JXG.Point or arbitrary number of JXG.Point elements.
      * @param direction Restricts the directions to be scaled. Possible values are 'x', 'y', 'xy'. Default value is 'xy'. By default, all points of the group are translation points.
      */
-    setScalePoints(objects: Point[], direction?: 'x' | 'y' | 'xy'): this;
+    setScalePoints(objects: Point | Point[], direction?: 'x' | 'y' | 'xy'): this;
     /**
      * Sets the translation points of the group. Dragging at one of these points results into a translation of the whole group.
      * @param objects Array of JXG.Point or arbitrary number of JXG.Point elements. By default, all points of the group are translation points.
      */
-    setTranslationPoints(objects: Point[]): this;
+    setTranslationPoints(objects: Point | Point[]): this;
     /**
      * Releases all elements of this group.
      */
@@ -1762,6 +1861,11 @@ declare module JXG {
   }
   export interface HyperbolaAttributes extends ConicAttributes { }
 
+  export interface Parabola extends Conic {
+    setAttribute(attributes: ParabolaAttributes): this;
+  }
+  export interface ParabolaAttributes extends ConicAttributes { }
+
   /**
    *
    */
@@ -2321,7 +2425,7 @@ declare module JXG {
      */
     postLabel?: string | StringFunction | number | NumberFunction | null;
     /**
-     * 
+     *
      */
     showInfobox?: boolean;
     /**
@@ -2468,54 +2572,127 @@ declare module JXG {
     L(): number;
     setAttribute(attributes: LineAttributes): this;
   }
+  /**
+   *
+   */
   export interface LineAttributes extends GeometryElementAttributes {
     /**
      * Determines whether the line has an arrow at the first defining point.
+     *
+     * type=7 is the default for curves if firstArrow: true
+     *
+     * Default Value: false
+     */
+    firstArrow?: boolean | { type?: 1 | 2 | 3 | 4 | 5 | 6 | 7; highlightSize?: number; size?: number };
+    /**
+     * Attributes for the line label.
      */
-    firstArrow?: boolean | { type?: number; highlightSize?: number; size?: number };
+    label?: LabelOptions;
     /**
      * Determines whether the line has an arrow at the second defining point.
+     *
+     * type=7 is the default for curves if lastArrow: true
+     *
+     * Default Value: false
      */
-    lastArrow?: boolean | { type?: number; highlightSize?: number; size?: number };
+    lastArrow?: boolean | { type?: 1 | 2 | 3 | 4 | 5 | 6 | 7; highlightSize?: number; size?: number };
     /**
+     * Line endings (linecap) of a straight line.
      *
+     * Not available for VML renderer.
+     *
+     * Default Value: 'butt'
+     */
+    lineCap?: 'butt' | 'round' | 'square';
+    /**
+     * Attributes for first defining point of the line.
      */
     point1?: PointAttributes;
     /**
-     *
+     * Attributes for second defining point of the line.
      */
     point2?: PointAttributes;
+    /**
+     * Defines together with Point#snapSizeY the grid the point snaps on to.
+     * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
+     * If this value is equal to or less than 0, it will use the grid displayed by the major ticks of the default ticks of the default x axes of the board.
+     *
+     * Default Value: 1
+     */
+    snapSizeX?: number;
+    /**
+     * Defines together with Point#snapSizeX the grid the point snaps on to.
+     * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
+     * If this value is equal to or less than 0, it will use the grid displayed by the major ticks of the default ticks of the default y axes of the board.
+     *
+     * Default Value: 1
+     */
+    snapSizeY?: number;
+    /**
+     * If set to true, the point will snap to a grid defined by Point#snapSizeX and Point#snapSizeY.
+     *
+     * Default Value: false
+     */
+    snapToGrid?: boolean;
     /**
      * Determines whether the line is drawn beyond the first defining point.
+     *
+     * If true, line stretches infinitely in direction of its first point. Otherwise it ends at point1.
+     *
+     * Default Value: true
      */
     straightFirst?: boolean;
     /**
      * Determines whether the line is drawn beyond the second defining point.
+     *
+     * If true, line stretches infinitely in direction of its second point. Otherwise it ends at point2.
+     *
+     * Default Value: true
      */
     straightLast?: boolean;
+    /**
+     * Attributes for ticks of the line.
+     */
+    ticks?: TicksOptions;
+    /**
+     * If set to true and Line#firstArrow is set to true, the arrow head will just touch the circle line of the start point of the line.
+     *
+     * Default Value: false
+     */
+    touchFirstPoint?: boolean;
+    /**
+     * If set to true and Line#lastArrow is set to true, the arrow head will just touch the circle line of the start point of the line.
+     *
+     * Default Value: false
+     */
+    touchLastPoint?: boolean;
   }
 
   export interface LineOptions extends GeometryElementAttributes {
     /**
      * Determines whether the line has an arrow at the first defining point.
      */
-    firstArrow?: boolean | { type?: number; highlightSize?: number; size?: number };
+    firstArrow?: boolean | { type?: 1 | 2 | 3 | 4 | 5 | 6 | 7; highlightSize?: number; size?: number };
     /**
      *
      */
     fixed?: boolean;
-    /**
-     * Determines whether the line has an arrow at the second defining point.
-     */
-    lastArrow?: boolean | { type?: number; highlightSize?: number; size?: number };
     /**
      *
      */
     label?: LabelOptions;
     /**
+     * Determines whether the line has an arrow at the second defining point.
+     */
+    lastArrow?: boolean | { type?: 1 | 2 | 3 | 4 | 5 | 6 | 7; highlightSize?: number; size?: number };
+    /**
+     * Line endings (linecap) of a straight line.
+     *
+     * Not available for VML renderer.
      *
+     * Default Value: 'butt'
      */
-    lineCap?: 'butt';
+    lineCap?: 'butt' | 'round' | 'square';
     /**
      *
      */
@@ -2658,7 +2835,7 @@ declare module JXG {
      * Attributes for the axis label.
      */
     label?: LabelOptions;
-    lastArrow?: ArrowSpecification;
+    lastArrow?: boolean | ArrowSpecification;
     margin?: number;
     /**
      * Attributes for the first point on the axis.
@@ -2773,8 +2950,61 @@ declare module JXG {
    */
   export class Ticks extends GeometryElement {
     constructor(line: Line, ticks: number | unknown[], attributes: TicksAttributes);
+
+    /**
+     * Equidistant ticks. Distance is defined by `ticksFunction`.
+     */
+    equidistant: boolean;
+
+    /**
+     * Array of fixed ticks.
+     */
+    fixedTicks: number[] | null;
+
+    /**
+     * To ensure the uniqueness of label ids this counter is used.
+     */
+    labelCounter: number;
+
+    /**
+     * Array where the labels are saved.
+     */
+    labels: Label[];
+
+    /**
+     * The line the ticks belong to.
+     */
+    line: Line;
+
+    /**
+     * Least distance between two ticks, measured in pixels.
+     */
+    minTicksDistance: number;
+
+    /**
+     * Stores the ticks coordinates as an array of length 3.
+     *
+     * The first two entries of the array are path coordinates in screen
+     * coordinates of the tick (arrays of length 2). The 3rd entry is true if
+     * the tick is a major tick, otherwise false.
+     *
+     * If the tick is outside of the canvas, the return array is empty.
+     */
+    ticks: Array<[[x1: number, x2: number], [y1: number, y2: number], boolean]>;
+
+    /**
+     * Distance between two major ticks in user coordinates
+     */
+    ticksDelta: number;
+
+    /**
+     * A function calculating ticks delta depending on the ticks number.
+     */
+    ticksFunction: () => number;
+
     setAttribute(attributes: TicksAttributes): this;
   }
+
   /**
    *
    */
@@ -2803,7 +3033,7 @@ declare module JXG {
     /**
      *
      */
-    generateLabelText?: ((labeled: Coords, center: Coords) => string) | null;
+    generateLabelText?: ((labeled: Coords, center: Coords, value: null | Number | String) => string) | null;
     /**
      *
      */
@@ -2879,10 +3109,10 @@ declare module JXG {
     defaultDistance?: number;
     drawLabels?: boolean;
     drawZero?: boolean;
-    face?: '|';
+    face?: '|' | '<' | '>';
     fillColor?: string;
-    generateLabelText?: ((one: Coords, two: Coords) => void) | null;
-    generateLabelValue?: ((one: Coords, two: Coords) => void) | null;
+    generateLabelText?: ((one: Coords, two: Coords, value: null|Number|String) => void) | null;
+    generateLabelValue?: ((labeled: Coords, center: Coords) => string) | null;
     highlightFillColor?: string;
     highlightStrokeColor?: string;
     includeBoundaries?: boolean | number;
@@ -2936,18 +3166,70 @@ declare module JXG {
     numberPoints?: number;
   }
 
+  export type TransformationType = 'generic' | 'reflect' | 'rotate' | 'scale' | 'shear' | 'translate'
+
+  /**
+   * A transformation consists of a 3x3 matrix, i.e. it is a projective transformation.
+   */
   export class Transformation extends GeometryElement {
-    constructor(board: Board, type: 'translate' | 'scale' | 'reflect' | 'rotate' | 'shear' | 'generic', params: unknown);
-    apply(p: GeometryElement): unknown[];
+    /**
+     * @param board The board the new circle is drawn on.
+     * @param type Can be 'translate', 'scale', 'reflect', 'rotate', 'shear', 'generic'
+     * @param params The parameters depend on the transformation type.
+     */
+    constructor(board: Board, type: TransformationType, params: unknown);
+    /**
+     * Transform a GeometryElement: First, the transformation matrix is updated, then do the matrix-vector-multiplication.
+     * @param p element which is transformed
+     */
+    private apply(p: GeometryElement): unknown[];
+    /**
+     * Applies a transformation once to a GeometryElement or an array of elements.
+     * If it is a free point, then it can be dragged around later and will overwrite the transformed coordinates.
+     * @param p
+     */
     applyOnce(p: GeometryElement | GeometryElement[]): void;
-    bindTo(element: GeometryElement | Point[]): void;
+    /**
+     * Binds a transformation to a GeometryElement or an array of elements.
+     * In every update of the GeometryElement(s), the transformation is executed.
+     * That means, in order to immediately apply the transformation, a call of board.update() has to follow.
+     * @param p JXG.Object or array of JXG.Object to which the transformation is bound to.
+     */
+    bindTo(p: GeometryElement | Point[]): void;
+    /**
+     * Combine two transformations to one transformation.
+     * This only works if both of transformation matrices consist solely of numbers, and do not contain functions.
+     * Multiplies the transformation with a transformation t from the left. i.e. (this) = (t) join (this)
+     * @param t Transformation which is the left multiplicand
+     * @returns the transformation object.
+     */
     melt(t: Transformation): Transformation;
-    setAttribute(attributes: TransformationAttributes): this;
-    setMatrix(board: Board, type: 'translate' | 'scale' | 'reflect' | 'rotate' | 'shear' | 'generic', params: unknown[], x: unknown, y: unknown, scale_x: unknown, scale_y: unknown): void;
+    /**
+     * Empty method. Unused.
+     * @param term Key-value pairs of the attributes.
+     */
+    setAttribute(term: TransformationAttributes): this;
+    /**
+     * Set the transformation matrix for different types of standard transforms.
+     * @param board
+     * @param type Transformation type, possible values are 'translate', 'scale', 'reflect', 'rotate', 'shear', 'generic'.
+     * @param params Parameters for the various transformation types.
+     * @param x Shift vector (number or function) in case of 'translate'.
+     * @param y Shift vector (number or function) in case of 'translate'.
+     * @param scale_x Scale vector (number or function) in case of 'scale'.
+     * @param scale_y Scale vector (number or function) in case of 'scale'.
+     */
+    setMatrix(board: Board, type: TransformationType, params: unknown[], x: NumberOrFunction, y: NumberOrFunction, scale_x: NumberOrFunction, scale_y: NumberOrFunction): void;
+    /**
+     * Updates the numerical data for the transformation, i.e. the entry of the subobject matrix.
+     */
     update(): this;
   }
+  /**
+   *
+   */
   export interface TransformationAttributes {
-    type: 'generic' | 'rotate' | 'scale' | 'translate';
+    type: TransformationType;
   }
 
   /**
@@ -3615,6 +3897,13 @@ declare module JXG {
     clickLeftArrow(): this;
     clickRightArrow(): this;
     clickUpArrow(): this;
+    /**
+     * Creates a new geometric element of type elementType.
+     * @param elementType Type of the element to be constructed given as a string e.g. 'point' or 'circle'.
+     * @param parents
+     * @param attributes
+     */
+    create<T extends GeometryElement | Composition | Array<GeometryElement>>(elementType: string, parents: unknown[], attributes?: Record<string, unknown>): T;
     /**
      *
      * @param elementType 'angle'
@@ -3793,7 +4082,7 @@ declare module JXG {
      * @param parents
      * @param attributes
      */
-    create(elementType: 'hyperbola', parents: unknown[], attributes?: {}): Hyperbola;
+    create(elementType: 'hyperbola', parents: unknown[], attributes?: HyperbolaAttributes): Hyperbola;
     /**
      *
      * @param elementType 'image'
@@ -3801,6 +4090,13 @@ declare module JXG {
      * @param attributes
      */
     create(elementType: 'image', parents: unknown[], attributes?: ImageAttributes): Image;
+    /**
+     *
+     * @param elementType 'inequality'
+     * @param parents
+     * @param attributes
+     */
+    create(elementType: 'inequality', parents: unknown[], attributes?: InequalityAttributes): Inequality;
     /**
      *
      * @param elementType 'input'
@@ -3864,6 +4160,13 @@ declare module JXG {
      * @param attributes
      */
     create(elementType: 'normal', parents: unknown[], attributes?: NormalAttributes): Normal;
+    /**
+     *
+     * @param elementType 'parabola'
+     * @param parents
+     * @param attributes
+     */
+    create(elementType: 'parabola', parents: unknown[], attributes?: ParabolaAttributes): Parabola;
     /**
      *
      * @param elementType 'perpendicular'
@@ -4034,7 +4337,7 @@ declare module JXG {
     /**
      *
      */
-    emulateColorBlindness(deficiency: 'protanopia' | 'deuteranopia' | 'tritanopia'): this;
+    emulateColorblindness(deficiency: 'protanopia' | 'deuteranopia' | 'tritanopia'): this;
     /**
      * After construction of the object the visibility is set and the label is constructed if necessary.
      * @param obj The object to add.
@@ -4052,10 +4355,10 @@ declare module JXG {
     getCoordsTopLeftCorner(): [number, number];
     getMousePosition(e: unknown, i?: number): [number, number];
     getScrCoordsOfMouse(x: number, y: number): [number, number];
-    getUseCoordsOfMouse(evt: unknown): [number, number];
+    getUsrCoordsOfMouse(evt: unknown): [number, number];
     hasPoint(x: number, y: number): boolean;
     highlightCustomInfobox(text: string, element?: GeometryElement): this;
-    highlightInfbox(x: number, y: number, element?: GeometryElement): this;
+    highlightInfobox(x: number, y: number, element?: GeometryElement): this;
     initInfobox(): this;
     initMoveObject(x: number, y: number, event: unknown, type: 'mouse' | 'pen' | 'touch'): GeometryElement[];
     initMoveOrigin(x: number, y: number): unknown;
@@ -4121,11 +4424,13 @@ declare module JXG {
     setZoom(fX: number, fY: number): Board;
     showDependencies(): this;
     showXML(): this;
+    startResizeObserver(): unknown;
     startSelectionMode(): unknown;
     /**
      * Cancels all running animations.
      */
     stopAllAnimation(): Board;
+    stopResizeObserver(): unknown;
     stopSelectionMode(): [Coords, Coords];
     /**
      * Stop updates of the board.
@@ -5266,3 +5571,10 @@ declare module JXG {
     rungeKutta(butcher: unknown, x0: number[], I: number[], N: number, f: unknown): number[][];
   }
 }
+
+/**
+ * JSXGraph in the module "jsxgraph".
+ */
+declare module "jsxgraph" {
+  export = JXG;
+}

package/distrib/intergeo.min.js

@@ -1,5 +1,5 @@
 /*
-    JSXGraph 1.4.2
+    JSXGraph 1.4.5
 
     Copyright 2008-2022
         Matthias Ehmann,