@duet3d/monacotokens 3.6.1 → 3.6.2

package/dist/monaco-stm32.js

@@ -0,0 +1,81 @@
+export const stm32Language = {
+    keywordsPrimary: ["8266wifi", "accelerometer", "atx", "board", "heat", "lcd", "led", "leds", "pins", "power", "sbc", "sdCard", "serial", "SPI0", "SPI1", "SPI2", "SPI3", "SPI4", "SPI5", "SPI6", "SPI7", "SPI8", "stepper"],
+    keywordsSecondary: ["clockReg", "csPin", "espDataReadyPin", "espResetPin", "TfrReadyPin", "serialRxTxPins", "spiChannel", "initialPowerOn", "powerPin", "powerPinInverted", "spiTempSensorChannel", "spiTempSensorCSPins", "tempSensePins", "thermistorSeriesResistor", "encoderPinA", "encoderPinB", "encoderPinSw", "lcdBeepPin", "lcdCSPin", "lcdDCPin", "panelButtonPin", "neopixelPin", "activity", "activityOn", "diagnostic", "diagnosticOn", "SetHigh", "SetLow", "VInDetectPin", "voltage", "loadConfig", "external", "internal", "aux", "aux2", "pins", "directionPins", "enablePins", "numSmartDrivers", "num5160Drivers", "stepPins", "TmcDiagPins", "TmcUartPins"],
+    keywordsTertiary: ["cardDetectPin", "csPin", "spiChannel", "spiFrequencyHz", "spiFrequencyHz", "rxTxPins", "rxTxPins"],
+    symbols: /[=><!~?:&|+\-*#\/\^%]+/,
+    operators: ['*', '/', '+', '-', "==", "!=", '=', "<=", '<', ">=", ">>>", ">>", '>', '!', "&&", '&', "||", '|', '^', '?', ':'],
+    includeLF: true,
+    tokenizer: {
+        root: [
+            // keywords
+            [/[a-zA-Z0-9_$][\w$]*/, {
+                    cases: {
+                        "@keywordsPrimary": { token: "keyword" },
+                        "@keywordsSecondary": { token: "keyword" },
+                        "@keywordsTertiary": { token: "keyword" }
+                    }
+                }],
+            // comments
+            [/\/\/.*/, "comment"],
+            [/;.*/, "comment"],
+            // expressions
+            [/{/, "operator", "@curlyBracket"],
+            // expressions
+            [/=/, "operator", "@equals"],
+        ],
+        expression: [
+            // numbers
+            [/\d+/, "number"],
+            // Pin Numbers
+            [/[a-iA-I]\.\d+/, "string"],
+            [/[a-iA-I]\_\d+/, "string"],
+            [/[a-iA-I]\d+/, "string"],
+            [/P[a-iA-I]\.\d+/, "string"],
+            [/P[a-iA-I]\_\d+/, "string"],
+            [/P[a-iA-I]\d+/, "string"],
+            [/NoPin/, "string"],
+            // strings
+            [/"(.|\"\")*?"/, "string"],
+            [/[a-zA-Z0-9_$][\w$]*/, "string"],
+            // operators
+            [/@symbols/, {
+                    cases: {
+                        "@operators": "operator",
+                        "@default": ""
+                    }
+                }],
+            // comments
+            [/;.*/, "comment"],
+            // EOL
+            [/\n/, "", "@popall"],
+        ],
+        curlyBracket: [
+            // curly brackets contain expressions
+            { include: "expression" },
+            // terminate when reaching a closing bracket
+            [/}/, "operator", "@pop"],
+        ],
+        equals: [
+            // curly brackets contain expressions
+            { include: "expression" },
+            // EOL
+            [/\n/, "", "@popall"],
+        ]
+    }
+};
+export const stm32LanguageConfiguration = {
+    comments: {
+        lineComment: ";"
+    },
+    brackets: [
+        ["{", "}"]
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "\"", close: "\"" }
+    ],
+    surroundingPairs: [
+        { open: "{", close: "}" },
+        { open: "\"", close: "\"" }
+    ]
+};

package/dist/objectmodel/deprecations.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Look up the deprecation message for a full object-model path (with literal numeric indices) or any of its
+ * prefixes. Returns the deprecation message when the path itself or a containing path is deprecated (the
+ * shallowest match wins so the user sees the root cause, e.g. `move.rotation.angle` reports `move.rotation`
+ * as deprecated). Returns null when neither the path nor any prefix is deprecated.
+ */
+export declare function getPathDeprecation(path: string): string | null;
+/**
+ * Look up the deprecation message for `parentPath + "." + field`. `parentPath` is the dotted path of the parent
+ * value from the root (e.g. `move.extruders[0]`), or empty for a top-level field. Returns null if not deprecated.
+ */
+export declare function getMemberDeprecation(parentPath: string, field: string): string | null;

package/dist/objectmodel/deprecations.js

@@ -0,0 +1,42 @@
+import deprecationsJson from "@duet3d/objectmodel/deprecations.json";
+import { normalisePath } from "./paths";
+/**
+ * Map of full object-model paths (with `[]` standing for any array index) to the deprecation message extracted
+ * from the property's `@deprecated` JSDoc tag. Built by @duet3d/objectmodel's build script from its TS sources.
+ */
+const deprecations = deprecationsJson;
+/**
+ * Look up the deprecation message for a full object-model path (with literal numeric indices) or any of its
+ * prefixes. Returns the deprecation message when the path itself or a containing path is deprecated (the
+ * shallowest match wins so the user sees the root cause, e.g. `move.rotation.angle` reports `move.rotation`
+ * as deprecated). Returns null when neither the path nor any prefix is deprecated.
+ */
+export function getPathDeprecation(path) {
+    if (!path) {
+        return null;
+    }
+    const key = normalisePath(path);
+    // Walk prefixes from shallowest to deepest; first hit wins
+    let cursor = 0;
+    while (cursor < key.length) {
+        // Advance to the next boundary (dot or closing bracket that ends a step)
+        let next = key.indexOf(".", cursor);
+        if (next < 0) {
+            next = key.length;
+        }
+        const prefix = key.substring(0, next);
+        if (Object.prototype.hasOwnProperty.call(deprecations, prefix)) {
+            return deprecations[prefix];
+        }
+        cursor = next + 1;
+    }
+    return null;
+}
+/**
+ * Look up the deprecation message for `parentPath + "." + field`. `parentPath` is the dotted path of the parent
+ * value from the root (e.g. `move.extruders[0]`), or empty for a top-level field. Returns null if not deprecated.
+ */
+export function getMemberDeprecation(parentPath, field) {
+    const fullPath = parentPath ? `${parentPath}.${field}` : field;
+    return getPathDeprecation(fullPath);
+}

package/dist/objectmodel/enums.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Return the list of valid values for a given object-model path, or null if the path has no known enum values.
+ */
+export declare function getEnumValuesForPath(path: string): string[] | null;

package/dist/objectmodel/enums.js

@@ -0,0 +1,17 @@
+import enumValuesJson from "@duet3d/objectmodel/enums.json";
+import { normalisePath } from "./paths";
+/**
+ * Map of full object-model paths (with `[]` standing for any array index) to the list of valid enum / string-
+ * literal values the field can take. Generated by @duet3d/objectmodel's build script from its TS sources.
+ */
+const enumValues = enumValuesJson;
+/**
+ * Return the list of valid values for a given object-model path, or null if the path has no known enum values.
+ */
+export function getEnumValuesForPath(path) {
+    if (!path) {
+        return null;
+    }
+    const key = normalisePath(path);
+    return Object.prototype.hasOwnProperty.call(enumValues, key) ? enumValues[key] : null;
+}

package/dist/objectmodel/machine-context.d.ts

@@ -0,0 +1,33 @@
+import type { ObjectModel } from "@duet3d/objectmodel";
+/**
+ * Runtime context describing the currently connected machine. Completion and hover providers read this to surface
+ * machine-specific information (visible axes, configured extruders, object-model fields) alongside the static
+ * gcode/expression datasets bundled with this package.
+ *
+ * Framework-agnostic: Vue, React, or any other consumer just calls `setMachineContext` when its model reference
+ * becomes available or changes. The reference is expected to stay stable - providers read field values through
+ * the reference at completion time so state mutations inside the object model are picked up automatically.
+ */
+export interface MachineContext {
+    /** Live machine object-model reference. */
+    readonly model: ObjectModel;
+    /**
+     * Optional callback that returns a Markdown/HTML description for an object-model path (with `[]` placeholders
+     * for collection items, e.g. `move.extruders[].pressureAdvance`). Used by the hover provider to surface the
+     * DuetAPI.xml documentation. Return `null` when no description is available. May be async - the hover provider
+     * awaits the result so callbacks can lazily fetch the docs on first hover without losing the popup.
+     */
+    readonly getObjectModelDescription?: (path: string) => string | null | Promise<string | null>;
+}
+/**
+ * Set (or clear) the runtime machine context. Pass `null` when the machine is disconnected.
+ */
+export declare function setMachineContext(context: MachineContext | null): void;
+/**
+ * Get the currently installed machine context, or null when no machine is connected.
+ */
+export declare function getMachineContext(): MachineContext | null;
+/**
+ * Subscribe to machine-context changes. Returns an unsubscribe function.
+ */
+export declare function onMachineContextChange(listener: () => void): () => void;

package/dist/objectmodel/machine-context.js

@@ -0,0 +1,30 @@
+let current = null;
+const listeners = new Set();
+/**
+ * Set (or clear) the runtime machine context. Pass `null` when the machine is disconnected.
+ */
+export function setMachineContext(context) {
+    current = context;
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch (e) {
+            // Listener threw - don't let it break other listeners
+            console.error("[monacotokens] machine-context listener threw:", e);
+        }
+    }
+}
+/**
+ * Get the currently installed machine context, or null when no machine is connected.
+ */
+export function getMachineContext() {
+    return current;
+}
+/**
+ * Subscribe to machine-context changes. Returns an unsubscribe function.
+ */
+export function onMachineContextChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/objectmodel/paths.d.ts

@@ -0,0 +1,3 @@
+/** Normalise a runtime object-model path (with literal numeric indices) to the lookup form used by
+ * the deprecations / enums maps, where `[]` stands in for any array index. */
+export declare function normalisePath(path: string): string;

package/dist/objectmodel/paths.js

@@ -0,0 +1,5 @@
+/** Normalise a runtime object-model path (with literal numeric indices) to the lookup form used by
+ * the deprecations / enums maps, where `[]` stands in for any array index. */
+export function normalisePath(path) {
+    return path.replace(/\[\d+\]/g, "[]");
+}

package/dist/providers.d.ts

@@ -0,0 +1,55 @@
+import type * as monaco from "monaco-editor-core/esm/vs/editor/editor.api.js";
+export { getMachineContext, onMachineContextChange } from "./objectmodel/machine-context";
+/**
+ * Flatten a machine object-model snapshot into a list of dotted paths (with `[0]` placeholders for arrays).
+ * Walks the entire reachable subtree; arrays contribute a single representative `[0]` entry so the list
+ * doesn't explode on machines with many tools/axes. Cycles are guarded via a visited WeakSet.
+ */
+export declare function flattenObjectModel(root: any): string[];
+/**
+ * Detect whether the cursor sits inside an RRF expression context:
+ *   - inside a balanced-but-still-open `{ ... }` span, OR
+ *   - after an `=` on a `set|var|global` line (whole line is expression territory), OR
+ *   - after `if|elif|while` (condition is an expression).
+ */
+export declare function isInsideExpression(beforeCursor: string): boolean;
+/**
+ * Find the closest G/M/T-code to the left of `column` on the given line.
+ * Returns the matched code (e.g. "G1") and the column where it starts, or null.
+ *
+ * A bare `T` is only treated as its own code when it's the first code on the line; otherwise it's a parameter
+ * letter of the preceding command (e.g. `M104 T1` - the T belongs to M104, not a separate `T` code).
+ */
+export declare function findCodeAtCursor(line: string, column: number): {
+    code: string;
+    startColumn: number;
+} | null;
+/**
+ * Register Duet-specific completion and hover providers for a language id.
+ */
+export declare function registerProvidersFor(monacoInstance: typeof monaco, languageId: string): monaco.IDisposable[];
+/**
+ * Register Duet completion and hover providers for both gcode-fdm and gcode-cnc languages.
+ */
+export declare function registerDuetProviders(monacoInstance: typeof monaco): monaco.IDisposable[];
+/**
+ * Attach a per-editor cursor-position watcher that closes the signature-help tooltip immediately when the cursor
+ * moves to a position where our provider would return null (between parameters, before the code, on a different line).
+ * Monaco only re-invokes the signature-help provider on content changes, so this bridges arrow-key / click movement.
+ * Call this once per editor right after `monaco.editor.create(...)`.
+ */
+export declare function attachGcodeSignatureHelpWatcher(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;
+/**
+ * Apply a strikethrough decoration (class `duet-deprecated-code`) to every occurrence of a deprecated G/M/T-code
+ * (e.g. `M557`) and to every deprecated parameter letter belonging to any G/M/T-code on that line (e.g. the `S` in
+ * `M84 S`). Re-runs on every content change; hover tooltip carries the deprecation reason.
+ * Call once per editor; the returned IDisposable removes the listener and clears the decorations.
+ */
+export declare function attachGcodeDeprecationDecorations(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;
+/**
+ * Strike-through deprecated object-model paths that appear in the editor. Matches dotted chains like
+ * `move.extruders[0].pressureAdvance`, normalises the bracket indices to `[]`, and highlights the chain if
+ * the normalised path is present in the deprecations map shipped by @duet3d/objectmodel. Re-runs on every
+ * content change; hover tooltip carries the deprecation reason.
+ */
+export declare function attachObjectModelDeprecationDecorations(editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;