@duet3d/objectmodel 3.5.0-beta.42 → 3.5.0-beta.44

package/dist/move/MoveCalibration.d.ts

@@ -0,0 +1,11 @@
+import ModelObject from "../ModelObject";
+export declare class MoveDeviations extends ModelObject {
+    deviation: number;
+    mean: number;
+}
+export declare class MoveCalibration extends ModelObject {
+    readonly final: MoveDeviations;
+    readonly initial: MoveDeviations;
+    numFactors: number;
+}
+export default MoveCalibration;

package/dist/move/MoveCalibration.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCalibration = exports.MoveDeviations = void 0;
+const ModelObject_1 = require("../ModelObject");
+class MoveDeviations extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.deviation = 0;
+        this.mean = 0;
+    }
+}
+exports.MoveDeviations = MoveDeviations;
+class MoveCalibration extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.final = new MoveDeviations();
+        this.initial = new MoveDeviations();
+        this.numFactors = 0;
+    }
+}
+exports.MoveCalibration = MoveCalibration;
+exports.default = MoveCalibration;

package/dist/move/MoveCompensation.d.ts

@@ -0,0 +1,30 @@
+import ModelObject from "../ModelObject";
+import { MoveDeviations } from "./MoveCalibration";
+export declare class ProbeGrid extends ModelObject {
+    axes: Array<string>;
+    maxs: Array<number>;
+    mins: Array<number>;
+    radius: number;
+    spacings: Array<number>;
+}
+export declare class Skew extends ModelObject {
+    compensateXY: boolean;
+    tanXY: number;
+    tanXZ: number;
+    tanYZ: number;
+}
+export declare enum MoveCompensationType {
+    none = "none",
+    mesh = "mesh"
+}
+export declare class MoveCompensation extends ModelObject {
+    constructor();
+    fadeHeight: number | null;
+    file: string | null;
+    liveGrid: ProbeGrid | null;
+    meshDeviation: MoveDeviations | null;
+    readonly probeGrid: ProbeGrid;
+    readonly skew: Skew;
+    type: MoveCompensationType;
+}
+export default MoveCompensation;

package/dist/move/MoveCompensation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCompensation = exports.MoveCompensationType = exports.Skew = exports.ProbeGrid = void 0;
+const ModelObject_1 = require("../ModelObject");
+const MoveCalibration_1 = require("./MoveCalibration");
+class ProbeGrid extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.axes = ['X', 'Y'];
+        this.maxs = [-1, -1];
+        this.mins = [0, 0];
+        this.radius = 0;
+        this.spacings = [0, 0];
+    }
+}
+exports.ProbeGrid = ProbeGrid;
+class Skew extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.compensateXY = true;
+        this.tanXY = 0;
+        this.tanXZ = 0;
+        this.tanYZ = 0;
+    }
+}
+exports.Skew = Skew;
+var MoveCompensationType;
+(function (MoveCompensationType) {
+    MoveCompensationType["none"] = "none";
+    MoveCompensationType["mesh"] = "mesh";
+})(MoveCompensationType = exports.MoveCompensationType || (exports.MoveCompensationType = {}));
+class MoveCompensation extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.fadeHeight = null;
+        this.file = null;
+        this.liveGrid = null;
+        this.meshDeviation = null;
+        this.probeGrid = new ProbeGrid();
+        this.skew = new Skew();
+        this.type = MoveCompensationType.none;
+        ModelObject_1.default.wrapModelProperty(this, "liveGrid", ProbeGrid);
+        ModelObject_1.default.wrapModelProperty(this, "meshDeviation", MoveCalibration_1.MoveDeviations);
+    }
+}
+exports.MoveCompensation = MoveCompensation;
+exports.default = MoveCompensation;

package/dist/move/index.d.ts

@@ -0,0 +1,61 @@
+import ModelObject from "../ModelObject";
+import ModelCollection from "../ModelCollection";
+import Axis from "./Axis";
+import Extruder from "./Extruder";
+import InputShaping from "./InputShaping";
+import KeepoutZone from "./KeepoutZone";
+import MoveCalibration from "./MoveCalibration";
+import MoveCompensation from "./MoveCompensation";
+import Kinematics from "./kinematics";
+export declare class CurrentMove extends ModelObject {
+    acceleration: number;
+    deceleration: number;
+    extrusionRate: number;
+    laserPwm: number | null;
+    requestedSpeed: number;
+    topSpeed: number;
+}
+export declare class MotorsIdleControl extends ModelObject {
+    factor: number;
+    timeout: number;
+}
+export declare class MoveQueueItem extends ModelObject {
+    gracePeriod: number;
+    length: number;
+}
+export declare class MoveRotation extends ModelObject {
+    angle: number;
+    centre: Array<number>;
+}
+export declare class Move extends ModelObject {
+    readonly axes: ModelCollection<Axis>;
+    backlashFactor: number;
+    readonly calibration: MoveCalibration;
+    readonly compensation: MoveCompensation;
+    readonly currentMove: CurrentMove;
+    readonly extruders: ModelCollection<Extruder>;
+    readonly idle: MotorsIdleControl;
+    readonly keepout: ModelCollection<KeepoutZone | null>;
+    kinematics: Kinematics;
+    limitAxes: boolean;
+    noMovesBeforeHoming: boolean;
+    printingAcceleration: number;
+    readonly queue: ModelCollection<MoveQueueItem>;
+    reducedAcceleration: number;
+    readonly rotation: MoveRotation;
+    readonly shaping: InputShaping;
+    speedFactor: number;
+    travelAcceleration: number;
+    virtualEPos: number;
+    workplaceNumber: number;
+}
+export default Move;
+export * from "./kinematics";
+export * from "./Axis";
+export * from "./DriverId";
+export * from "./Extruder";
+export * from "./InputShaping";
+export * from "./KeepoutZone";
+export * from "./Microstepping";
+export * from "./MoveCalibration";
+export * from "./MoveCompensation";

package/dist/move/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Move = exports.MoveRotation = exports.MoveQueueItem = exports.MotorsIdleControl = exports.CurrentMove = void 0;
+const ModelObject_1 = require("../ModelObject");
+const ModelCollection_1 = require("../ModelCollection");
+const Axis_1 = require("./Axis");
+const Extruder_1 = require("./Extruder");
+const InputShaping_1 = require("./InputShaping");
+const KeepoutZone_1 = require("./KeepoutZone");
+const MoveCalibration_1 = require("./MoveCalibration");
+const MoveCompensation_1 = require("./MoveCompensation");
+const kinematics_1 = require("./kinematics");
+class CurrentMove extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.acceleration = 0;
+        this.deceleration = 0;
+        this.extrusionRate = 0;
+        this.laserPwm = null;
+        this.requestedSpeed = 0;
+        this.topSpeed = 0;
+    }
+}
+exports.CurrentMove = CurrentMove;
+class MotorsIdleControl extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.factor = 0.3;
+        this.timeout = 30;
+    }
+}
+exports.MotorsIdleControl = MotorsIdleControl;
+class MoveQueueItem extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.gracePeriod = 0;
+        this.length = 0;
+    }
+}
+exports.MoveQueueItem = MoveQueueItem;
+class MoveRotation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angle = 0;
+        this.centre = [0, 0];
+    }
+}
+exports.MoveRotation = MoveRotation;
+class Move extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.axes = new ModelCollection_1.default(Axis_1.default);
+        this.backlashFactor = 10;
+        this.calibration = new MoveCalibration_1.default();
+        this.compensation = new MoveCompensation_1.default();
+        this.currentMove = new CurrentMove();
+        this.extruders = new ModelCollection_1.default(Extruder_1.default);
+        this.idle = new MotorsIdleControl();
+        this.keepout = new ModelCollection_1.default(KeepoutZone_1.default);
+        this.kinematics = new kinematics_1.CoreKinematics(kinematics_1.KinematicsName.cartesian);
+        this.limitAxes = true;
+        this.noMovesBeforeHoming = true;
+        this.printingAcceleration = 10000;
+        this.queue = new ModelCollection_1.default(MoveQueueItem);
+        this.reducedAcceleration = 10000;
+        this.rotation = new MoveRotation();
+        this.shaping = new InputShaping_1.default();
+        this.speedFactor = 1;
+        this.travelAcceleration = 10000;
+        this.virtualEPos = 0;
+        this.workplaceNumber = 0;
+    }
+}
+exports.Move = Move;
+exports.default = Move;
+__exportStar(require("./kinematics"), exports);
+__exportStar(require("./Axis"), exports);
+__exportStar(require("./DriverId"), exports);
+__exportStar(require("./Extruder"), exports);
+__exportStar(require("./InputShaping"), exports);
+__exportStar(require("./KeepoutZone"), exports);
+__exportStar(require("./Microstepping"), exports);
+__exportStar(require("./MoveCalibration"), exports);
+__exportStar(require("./MoveCompensation"), exports);

package/dist/move/kinematics/CoreKinematics.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import { KinematicsName, ZLeadscrewKinematics } from "./KinematicsBase";
+export declare class CoreKinematics extends ZLeadscrewKinematics {
+    constructor(name: KinematicsName);
+    forwardMatrix: Array<Array<number>>;
+    inverseMatrix: Array<Array<number>>;
+    update(jsonElement: any): IModelObject | null;
+}
+export default CoreKinematics;

package/dist/move/kinematics/CoreKinematics.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class CoreKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    constructor(name) {
+        super(name);
+        this.forwardMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+        this.inverseMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.CoreKinematics = CoreKinematics;
+exports.default = CoreKinematics;

package/dist/move/kinematics/DeltaKinematics.d.ts

@@ -0,0 +1,20 @@
+import ModelCollection from "../../ModelCollection";
+import ModelObject, { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class DeltaTower extends ModelObject {
+    angleCorrection: number;
+    diagonal: number;
+    endstopAdjustment: number;
+    xPos: number;
+    yPos: number;
+}
+export declare class DeltaKinematics extends KinematicsBase {
+    deltaRadius: number;
+    homedHeight: number;
+    printRadius: number;
+    readonly towers: ModelCollection<DeltaTower>;
+    xTilt: number;
+    yTilt: number;
+    update(jsonElement: any): IModelObject | null;
+}
+export default DeltaKinematics;

package/dist/move/kinematics/DeltaKinematics.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaKinematics = exports.DeltaTower = void 0;
+const ModelCollection_1 = require("../../ModelCollection");
+const ModelObject_1 = require("../../ModelObject");
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class DeltaTower extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angleCorrection = 0;
+        this.diagonal = 0;
+        this.endstopAdjustment = 0;
+        this.xPos = 0;
+        this.yPos = 0;
+    }
+}
+exports.DeltaTower = DeltaTower;
+class DeltaKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(...arguments);
+        this.deltaRadius = 0;
+        this.homedHeight = 0;
+        this.printRadius = 0;
+        this.towers = (0, ModelCollection_1.initCollection)(DeltaTower, [{}, {}, {}]);
+        this.xTilt = 0;
+        this.yTilt = 0;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.DeltaKinematics = DeltaKinematics;
+exports.default = DeltaKinematics;

package/dist/move/kinematics/HangprinterKinematics.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class HangprinterKinematics extends KinematicsBase {
+    anchors: Array<Array<number>>;
+    printRadius: number;
+    constructor();
+    update(jsonElement: any): IModelObject | null;
+}
+export default HangprinterKinematics;

package/dist/move/kinematics/HangprinterKinematics.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HangprinterKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class HangprinterKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.hangprinter);
+        this.anchors = [
+            [0, -2000, -100],
+            [2000, 1000, -100],
+            [-2000, 1000, -100],
+            [0, 0, 3000]
+        ];
+        this.printRadius = 1500;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.HangprinterKinematics = HangprinterKinematics;
+exports.default = HangprinterKinematics;

package/dist/move/kinematics/KinematicsBase.d.ts

@@ -0,0 +1,37 @@
+import ModelObject from "../../ModelObject";
+export declare enum KinematicsName {
+    cartesian = "cartesian",
+    coreXY = "coreXY",
+    coreXYU = "coreXYU",
+    coreXYUV = "coreXYUV",
+    coreXZ = "coreXZ",
+    markForged = "markForged",
+    fiveBarScara = "FiveBarScara",
+    hangprinter = "Hangprinter",
+    delta = "delta",
+    polar = "Polar",
+    rotaryDelta = "Rotary delta",
+    scara = "Scara",
+    unknown = "unknown"
+}
+export declare class MoveSegmentation extends ModelObject {
+    segmentsPerSec: number;
+    minSegmentLength: number;
+}
+export declare abstract class KinematicsBase extends ModelObject {
+    readonly name: KinematicsName;
+    readonly segmentation: MoveSegmentation;
+    constructor(name: KinematicsName);
+}
+export default KinematicsBase;
+export declare class TiltCorrection extends ModelObject {
+    correctionFactor: number;
+    lastCorrections: Array<number>;
+    maxCorrection: number;
+    screwPitch: number;
+    screwX: Array<number>;
+    screwY: Array<number>;
+}
+export declare abstract class ZLeadscrewKinematics extends KinematicsBase {
+    readonly tiltCorrection: TiltCorrection;
+}

package/dist/move/kinematics/KinematicsBase.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLeadscrewKinematics = exports.TiltCorrection = exports.KinematicsBase = exports.MoveSegmentation = exports.KinematicsName = void 0;
+const ModelObject_1 = require("../../ModelObject");
+var KinematicsName;
+(function (KinematicsName) {
+    KinematicsName["cartesian"] = "cartesian";
+    KinematicsName["coreXY"] = "coreXY";
+    KinematicsName["coreXYU"] = "coreXYU";
+    KinematicsName["coreXYUV"] = "coreXYUV";
+    KinematicsName["coreXZ"] = "coreXZ";
+    KinematicsName["markForged"] = "markForged";
+    KinematicsName["fiveBarScara"] = "FiveBarScara";
+    KinematicsName["hangprinter"] = "Hangprinter";
+    KinematicsName["delta"] = "delta";
+    KinematicsName["polar"] = "Polar";
+    KinematicsName["rotaryDelta"] = "Rotary delta";
+    KinematicsName["scara"] = "Scara";
+    KinematicsName["unknown"] = "unknown";
+})(KinematicsName = exports.KinematicsName || (exports.KinematicsName = {}));
+class MoveSegmentation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.segmentsPerSec = 0;
+        this.minSegmentLength = 0;
+    }
+}
+exports.MoveSegmentation = MoveSegmentation;
+class KinematicsBase extends ModelObject_1.default {
+    constructor(name) {
+        super();
+        this.segmentation = new MoveSegmentation();
+        this.name = name;
+    }
+}
+exports.KinematicsBase = KinematicsBase;
+exports.default = KinematicsBase;
+class TiltCorrection extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.correctionFactor = 0;
+        this.lastCorrections = [];
+        this.maxCorrection = 0;
+        this.screwPitch = 0;
+        this.screwX = [];
+        this.screwY = [];
+    }
+}
+exports.TiltCorrection = TiltCorrection;
+class ZLeadscrewKinematics extends KinematicsBase {
+    constructor() {
+        super(...arguments);
+        this.tiltCorrection = new TiltCorrection();
+    }
+}
+exports.ZLeadscrewKinematics = ZLeadscrewKinematics;

package/dist/move/kinematics/PolarKinematics.d.ts

@@ -0,0 +1,7 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class PolarKinematics extends KinematicsBase {
+    constructor();
+    update(jsonElement: any): IModelObject | null;
+}
+export default PolarKinematics;

package/dist/move/kinematics/PolarKinematics.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class PolarKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.polar);
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.PolarKinematics = PolarKinematics;
+exports.default = PolarKinematics;

package/dist/move/kinematics/ScaraKinematics.d.ts

@@ -0,0 +1,6 @@
+import { IModelObject } from "../../ModelObject";
+import { ZLeadscrewKinematics } from "./KinematicsBase";
+export declare class ScaraKinematics extends ZLeadscrewKinematics {
+    update(jsonElement: any): IModelObject | null;
+}
+export default ScaraKinematics;

package/dist/move/kinematics/ScaraKinematics.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaraKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class ScaraKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.ScaraKinematics = ScaraKinematics;
+exports.default = ScaraKinematics;

package/dist/move/kinematics/index.d.ts

@@ -0,0 +1,14 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase, { KinematicsName } from "./KinematicsBase";
+export declare class Kinematics extends KinematicsBase {
+    constructor(name?: KinematicsName);
+    update(jsonElement: any): IModelObject | null;
+}
+export default Kinematics;
+export declare function getKinematics(name: KinematicsName): KinematicsBase;
+export * from "./CoreKinematics";
+export * from "./DeltaKinematics";
+export * from "./HangprinterKinematics";
+export * from "./KinematicsBase";
+export * from "./PolarKinematics";
+export * from "./ScaraKinematics";

package/dist/move/kinematics/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKinematics = exports.Kinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const CoreKinematics_1 = require("./CoreKinematics");
+const DeltaKinematics_1 = require("./DeltaKinematics");
+const HangprinterKinematics_1 = require("./HangprinterKinematics");
+const ScaraKinematics_1 = require("./ScaraKinematics");
+const PolarKinematics_1 = require("./PolarKinematics");
+class Kinematics extends KinematicsBase_1.default {
+    constructor(name = KinematicsBase_1.KinematicsName.cartesian) {
+        super(name);
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return getKinematics(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.Kinematics = Kinematics;
+exports.default = Kinematics;
+function getKinematics(name) {
+    switch (name) {
+        case KinematicsBase_1.KinematicsName.cartesian:
+        case KinematicsBase_1.KinematicsName.coreXY:
+        case KinematicsBase_1.KinematicsName.coreXYU:
+        case KinematicsBase_1.KinematicsName.coreXYUV:
+        case KinematicsBase_1.KinematicsName.coreXZ:
+        case KinematicsBase_1.KinematicsName.markForged:
+            return new CoreKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.delta:
+            return new DeltaKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.rotaryDelta:
+            return new Kinematics(name);
+        case KinematicsBase_1.KinematicsName.hangprinter:
+            return new HangprinterKinematics_1.default();
+        case KinematicsBase_1.KinematicsName.fiveBarScara:
+        case KinematicsBase_1.KinematicsName.scara:
+            return new ScaraKinematics_1.default(name);
+        case KinematicsBase_1.KinematicsName.polar:
+            return new PolarKinematics_1.default();
+        default:
+            const _exhaustiveCheck = name;
+        case KinematicsBase_1.KinematicsName.unknown:
+            console.warn(`Kinematics '${name}' is not supported, falling back to cartesian`);
+            return new CoreKinematics_1.default(name);
+    }
+}
+exports.getKinematics = getKinematics;
+__exportStar(require("./CoreKinematics"), exports);
+__exportStar(require("./DeltaKinematics"), exports);
+__exportStar(require("./HangprinterKinematics"), exports);
+__exportStar(require("./KinematicsBase"), exports);
+__exportStar(require("./PolarKinematics"), exports);
+__exportStar(require("./ScaraKinematics"), exports);