fullcontrol-js/dist/index.d.ts

FullControl TypeScript rewrite - API parity mirror of Python library (G-code generation & geometry)

interface InitObject<T> {
    [key: string]: any;
}
declare abstract class BaseModelPlus {
    constructor(init?: InitObject<any>, enforceKeys?: readonly string[]);
    updateFrom(source: any): void;
    update_from(source: any): void;
    copy<T extends this>(): T;
}

declare class Point extends BaseModelPlus {
    x?: number;
    y?: number;
    z?: number;
    color?: [number, number, number];
    extrude?: boolean;
    speed?: number;
    static readonly typeName = "Point";
    constructor(init?: Partial<Point>);
    toJSON(): {
        x: number | undefined;
        y: number | undefined;
        z: number | undefined;
        color: [number, number, number] | undefined;
        extrude: boolean | undefined;
        speed: number | undefined;
    };
    static fromJSON(data: any): Point;
    XYZ_gcode(prev: Point): string | undefined;
    gcode(state: any): string | undefined;
}

declare class Vector {
    x?: number;
    y?: number;
    z?: number;
    constructor(init?: Partial<Vector>);
    static readonly typeName = "Vector";
    toJSON(): {
        x: number | undefined;
        y: number | undefined;
        z: number | undefined;
    };
    static fromJSON(data: any): Vector;
}

declare class ExtrusionGeometry extends BaseModelPlus {
    area_model?: 'rectangle' | 'stadium' | 'circle' | 'manual';
    width?: number;
    height?: number;
    diameter?: number;
    area?: number;
    static readonly typeName = "ExtrusionGeometry";
    constructor(init?: Partial<ExtrusionGeometry>);
    update_area(): void;
    toJSON(): {
        area_model: "rectangle" | "stadium" | "circle" | "manual" | undefined;
        width: number | undefined;
        height: number | undefined;
        diameter: number | undefined;
        area: number | undefined;
    };
    static fromJSON(d: any): ExtrusionGeometry;
    gcode(state: any): undefined;
}
declare class StationaryExtrusion extends BaseModelPlus {
    volume: number;
    speed: number;
    static readonly typeName = "StationaryExtrusion";
    constructor(init?: Partial<StationaryExtrusion>);
    toJSON(): {
        volume: number;
        speed: number;
    };
    static fromJSON(d: any): StationaryExtrusion;
    gcode(state: any): string;
}
declare class Extruder extends BaseModelPlus {
    on?: boolean;
    units?: 'mm' | 'mm3';
    dia_feed?: number;
    relative_gcode?: boolean;
    volume_to_e?: number;
    total_volume?: number;
    total_volume_ref?: number;
    travel_format?: 'G1_E0' | 'none';
    retraction_length?: number;
    retraction_speed?: number;
    static readonly typeName = "Extruder";
    constructor(init?: Partial<Extruder>);
    update_e_ratio(): void;
    get_and_update_volume(volume: number): number;
    toJSON(): {
        on: boolean | undefined;
        units: "mm" | "mm3" | undefined;
        dia_feed: number | undefined;
        relative_gcode: boolean | undefined;
    };
    static fromJSON(d: any): Extruder;
    e_gcode(point1: Point, state: any): string;
    gcode(state: any): "M83 ; relative extrusion" | "M82 ; absolute extrusion\nG92 E0 ; reset extrusion position to zero" | undefined;
}
declare class Retraction extends BaseModelPlus {
    length?: number;
    speed?: number;
    static readonly typeName = "Retraction";
    constructor(init?: Partial<Retraction>);
    toJSON(): {
        length: number | undefined;
        speed: number | undefined;
    };
    static fromJSON(d: any): Retraction;
    gcode(state: any): string | undefined;
}
declare class Unretraction extends BaseModelPlus {
    length?: number;
    speed?: number;
    static readonly typeName = "Unretraction";
    constructor(init?: Partial<Unretraction>);
    toJSON(): {
        length: number | undefined;
        speed: number | undefined;
    };
    static fromJSON(d: any): Unretraction;
    gcode(state: any): string | undefined;
}

declare class Printer extends BaseModelPlus {
    print_speed?: number;
    travel_speed?: number;
    command_list?: Record<string, string>;
    new_command?: Record<string, string>;
    speed_changed?: boolean;
    static readonly typeName = "Printer";
    constructor(init?: Partial<Printer>);
    f_gcode(state: any): string;
    gcode(state: any): undefined;
    toJSON(): {
        print_speed: number | undefined;
        travel_speed: number | undefined;
    };
    static fromJSON(d: any): Printer;
}

declare class Buildplate extends BaseModelPlus {
    static readonly typeName = "Buildplate";
    temp?: number;
    wait?: boolean;
    constructor(init?: Partial<Buildplate>);
    gcode(): string;
}
declare class Hotend extends BaseModelPlus {
    static readonly typeName = "Hotend";
    temp?: number;
    wait?: boolean;
    tool?: number;
    constructor(init?: Partial<Hotend>);
    gcode(): string;
}
declare class Fan extends BaseModelPlus {
    static readonly typeName = "Fan";
    speed_percent: number;
    part_fan_index?: number;
    constructor(init?: Partial<Fan>);
    gcode(): string;
}

interface GcodeStateLike {
    printer: Printer;
    gcode: string[];
}
declare class PrinterCommand extends BaseModelPlus {
    id?: string;
    static readonly typeName = "PrinterCommand";
    constructor(init?: Partial<PrinterCommand>);
    gcode(state: GcodeStateLike): string | undefined;
}
declare class ManualGcode extends BaseModelPlus {
    text?: string;
    static readonly typeName = "ManualGcode";
    constructor(init?: Partial<ManualGcode>);
    gcode(): string | undefined;
}
declare class GcodeComment extends BaseModelPlus {
    text?: string;
    end_of_previous_line_text?: string;
    static readonly typeName = "GcodeComment";
    constructor(init?: Partial<GcodeComment>);
    gcode(state: GcodeStateLike): string | undefined;
}

declare class GcodeControls extends BaseModelPlus {
    printer_name?: string;
    initialization_data?: Record<string, any>;
    save_as?: string;
    include_date?: boolean;
    show_banner: boolean;
    show_tips: boolean;
    silent: boolean;
    static readonly typeName = "GcodeControls";
    constructor(init?: Partial<GcodeControls>);
    initialize(): void;
}
declare class PlotControls extends BaseModelPlus {
    color_type: string;
    line_width?: number;
    style?: 'tube' | 'line';
    tube_type: 'flow' | 'cylinders';
    tube_sides: number;
    zoom: number;
    hide_annotations: boolean;
    hide_travel: boolean;
    hide_axes: boolean;
    neat_for_publishing: boolean;
    raw_data: boolean;
    printer_name: string;
    initialization_data?: Record<string, any>;
    static readonly typeName = "PlotControls";
    constructor(init?: Partial<PlotControls>);
    initialize(): void;
}

declare class PlotAnnotation extends BaseModelPlus {
    point?: Point;
    label?: string;
    static readonly typeName = "PlotAnnotation";
    constructor(init?: Partial<PlotAnnotation>);
    visualize(state: any, plot_data: any, _plot_controls: any): void;
}

interface PolarPoint {
    radius: number;
    angle: number;
}
declare function polar_to_point(centre: Point, radius: number, angle: number): Point;
declare function point_to_polar(target_point: Point, origin_point: Point): PolarPoint;
declare function polar_to_vector(length: number, angle: number): Vector;

declare function midpoint(p1: Point, p2: Point): Point;
declare function interpolated_point(p1: Point, p2: Point, f: number): Point;
declare function centreXY_3pt(p1: Point, p2: Point, p3: Point): Point;

declare function distance(p1: Point, p2: Point): number;
declare function angleXY_between_3_points(start: Point, mid: Point, end: Point): number;
declare function path_length(points: Point[]): number;

declare function move(geometry: Point | any[], vector: Vector, copy?: boolean, copy_quantity?: number): Point | any[];
declare function move_geometry(geometry: Point | any[], vector: Vector): Point | any[];
declare function copy_geometry(geometry: Point | any[], vector: Vector, quantity: number): any[];

declare function move_polar(geometry: Point | any[], centre: Point, radius: number, angle: number, copy?: boolean, copy_quantity?: number): Point | any[];
declare function move_geometry_polar(geometry: Point | any[], centre: Point, radius: number, angle: number): Point | any[];
declare function copy_geometry_polar(geometry: Point | any[], centre: Point, radius: number, angle: number, quantity: number): any[];

declare function reflectXY_mc(p: Point, m_reflect: number, c_reflect: number): Point;
declare function reflectXY(p: Point, p1: Point, p2: Point): Point;

declare function reflectXYpolar(p: Point, preflect: Point, angle_reflect: number): Point;

declare function segmented_line(p1: Point, p2: Point, segments: number): Point[];
declare function segmented_path(points: Point[], segments: number): Point[];

declare function arcXY(centre: Point, radius: number, start_angle: number, arc_angle: number, segments?: number): Point[];
declare function variable_arcXY(centre: Point, start_radius: number, start_angle: number, arc_angle: number, segments?: number, radius_change?: number, z_change?: number): Point[];
declare function elliptical_arcXY(centre: Point, a: number, b: number, start_angle: number, arc_angle: number, segments?: number): Point[];
declare function arcXY_3pt(p1: Point, p2: Point, p3: Point, segments?: number): Point[];

declare function ramp_xyz(list: Point[], x_change?: number, y_change?: number, z_change?: number): Point[];
declare function ramp_polar(list: Point[], centre: Point, radius_change?: number, angle_change?: number): Point[];

declare function rectangleXY(start: Point, x_size: number, y_size: number, cw?: boolean): Point[];
declare function circleXY(centre: Point, radius: number, start_angle: number, segments?: number, cw?: boolean): Point[];
declare function circleXY_3pt(p1: Point, p2: Point, p3: Point, start_angle?: number, start_at_first_point?: boolean, segments?: number, cw?: boolean): Point[];
declare function ellipseXY(centre: Point, a: number, b: number, start_angle: number, segments?: number, cw?: boolean): Point[];
declare function polygonXY(centre: Point, enclosing_radius: number, start_angle: number, sides: number, cw?: boolean): Point[];
declare function spiralXY(centre: Point, start_radius: number, end_radius: number, start_angle: number, n_turns: number, segments: number, cw?: boolean): Point[];
declare function helixZ(centre: Point, start_radius: number, end_radius: number, start_angle: number, n_turns: number, pitch_z: number, segments: number, cw?: boolean): Point[];

declare function squarewaveXYpolar(start: Point, direction_polar: number, amplitude: number, line_spacing: number, periods: number, extra_half_period?: boolean, extra_end_line?: boolean): Point[];
declare function squarewaveXY(start: Point, direction_vector: Vector, amplitude: number, line_spacing: number, periods: number, extra_half_period?: boolean, extra_end_line?: boolean): Point[];
declare function trianglewaveXYpolar(start: Point, direction_polar: number, amplitude: number, tip_separation: number, periods: number, extra_half_period?: boolean): Point[];
declare function sinewaveXYpolar(start: Point, direction_polar: number, amplitude: number, period_length: number, periods: number, segments_per_period?: number, extra_half_period?: boolean, phase_shift?: number): Point[];

declare function travel_to(geometry: Point | any[]): any[];

declare function flatten<T>(steps: (T | T[])[]): T[];
declare function linspace(start: number, end: number, number_of_points: number): number[];
declare function points_only(steps: any[], track_xyz?: boolean): Point[];
declare function relative_point(reference: Point | any[], x_offset: number, y_offset: number, z_offset: number): Point;
declare function first_point(steps: any[], fully_defined?: boolean): Point;
declare function last_point(steps: any[], fully_defined?: boolean): Point;
declare function export_design(steps: any[], filename?: string): string;
declare function import_design(registry: Record<string, any>, jsonOrFilename: string): any[];
declare function build_default_registry(): Record<string, any>;

declare function check(steps: any[]): void;
declare function fix(steps: any[], result_type: 'gcode' | 'plot', controls: any): any[];
declare function check_points(geometry: Point | any[], checkType: string): void;

interface StepContext {
    prevPoint?: Point;
    lastGcodeLine?: string;
    state: State;
}
type Step = any;
declare class State {
    steps: Step[];
    gcodeLines: string[];
    points: Point[];
    extruders: Extruder[];
    printer?: Printer;
    annotations: any[];
    point: Point;
    extruder: Extruder;
    extrusion_geometry: ExtrusionGeometry;
    constructor(steps?: Step[], options?: {
        initialization_data?: any;
        printer_name?: string;
    });
    addPoint(p: Point): void;
    addGcode(line: string): void;
    register(step: Step): void;
}

declare function generate_gcode(state: State, controls?: Partial<GcodeControls>): string;

interface PlotDataPoint {
    x?: number;
    y?: number;
    z?: number;
    color?: string;
}
interface PlotData {
    points: PlotDataPoint[];
    annotations: any[];
}
declare function build_plot_data(state: State): PlotData;

interface TransformResult {
    gcode: string;
    plot: ReturnType<typeof build_plot_data>;
    state: State;
}
declare function transform(steps: any[], result_type?: 'gcode' | 'plot', controls?: Partial<GcodeControls>): TransformResult;

interface ImportPrinterResult {
    starting_procedure_steps: any[];
    ending_procedure_steps: any[];
    [k: string]: any;
}
declare function import_printer(printer_name: string, user_overrides: Record<string, any>): ImportPrinterResult;

export { Buildplate, Extruder, ExtrusionGeometry, Fan, GcodeComment, GcodeControls, type GcodeStateLike, Hotend, ManualGcode, PlotAnnotation, PlotControls, type PlotData, type PlotDataPoint, Point, type PolarPoint, Printer, PrinterCommand, Retraction, State, StationaryExtrusion, type Step, type StepContext, type TransformResult, Unretraction, Vector, angleXY_between_3_points, arcXY, arcXY_3pt, build_default_registry, build_plot_data, centreXY_3pt, check, check_points, circleXY, circleXY_3pt, copy_geometry, copy_geometry_polar, distance, ellipseXY, elliptical_arcXY, export_design, first_point, fix, flatten, generate_gcode, helixZ, import_design, import_printer, interpolated_point, last_point, linspace, midpoint, move, move_geometry, move_geometry_polar, move_polar, path_length, point_to_polar, points_only, polar_to_point, polar_to_vector, polygonXY, ramp_polar, ramp_xyz, rectangleXY, reflectXY, reflectXY_mc, reflectXYpolar, relative_point, segmented_line, segmented_path, sinewaveXYpolar, spiralXY, squarewaveXY, squarewaveXYpolar, transform, travel_to, trianglewaveXYpolar, variable_arcXY };