@duet3d/monacotokens 3.7.0-alpha.2 → 3.7.0-alpha.3

package/dist/monaco-gcode.js

@@ -10,8 +10,12 @@ function generateMonarchLanguage(fdmMode) {
         consts: ["true", "false", "iterations", "line", "null", "pi", "result", "input"],
         functions: ["abs", "acos", "asin", "atan", "atan2", "ceil", "cos", "datetime", "degrees", "drop", "exists", "exp", "fileexists", "fileread",
             "find", "floor", "isnan", "log", "max", "min", "mod", "pow", "radians", "random", "round", "sin", "sqrt", "square", "take", "tan", "vector"],
-        keywords: ["abort", "echo", "if", "elif", "while", "set"],
-        noArgKeywords: ["else", "break", "continue"],
+        // Non-flow meta keywords that take an expression after (abort/echo/set) - render as regular keywords (blue)
+        keywords: ["abort", "echo", "set"],
+        // Flow-control keywords that take a condition/expression - render in Monaco's flow-keyword purple (matches VSCode)
+        flowExprKeywords: ["if", "elif", "while"],
+        // Flow-control keywords that stand alone - render in the same purple as flowExprKeywords
+        flowNoArgKeywords: ["else", "break", "continue"],
         varKeywords: ["global", "var"],
         symbols: /[=><!~?:&|+\-*#\/\^%]+/,
         operators: ['*', '/', '+', '-', "==", "!=", '=', "<=", '<', ">=", ">>>", ">>", '>', '!', "&&", '&', "||", '|', '^', '?', ':'],
@@ -20,7 +24,10 @@ function generateMonarchLanguage(fdmMode) {
             root: [
                 // line numbers
                 [/[nN]\d+/, "type"],
-                // G/M/T-codes
+                // G53 acting as a same-line prefix (e.g. "G53 G1 X10") - highlight as a modifier, distinct from both
+                // line numbers (type) and regular codes (keyword)
+                [/[gG]53(?=[\s]+[gGmMtT][0-9-])/, "regexp", "afterG53"],
+                // G/M/T-codes (including bare G53 on its own line, which behaves like a regular command)
                 [/[gG][0123](?=\D)/, "keyword", fdmMode ? "normalGcode" : "moveGcode"],
                 [/[gGmM]\d+(\.\d+)?/, "keyword", "normalGcode"],
                 [/[tT](?=\{)/, "keyword", "normalGcodeWithT"],
@@ -29,7 +36,8 @@ function generateMonarchLanguage(fdmMode) {
                 [/[a-z_$][\w$]*/, {
                         cases: {
                             "@keywords": { token: "keyword", next: "@lineExpression" },
-                            "@noArgKeywords": { token: "keyword" },
+                            "@flowExprKeywords": { token: "keyword.flow", next: "@lineExpression" },
+                            "@flowNoArgKeywords": { token: "keyword.flow" },
                             "@varKeywords": { token: "keyword", next: "varName" }
                         }
                     }],
@@ -44,12 +52,17 @@ function generateMonarchLanguage(fdmMode) {
                 [/;.*/, "comment"],
                 [/\(.*\)/, fdmMode ? "invalid" : "comment"]
             ],
+            afterG53: [
+                // whitespace between the G53 prefix and the following G/M/T-code
+                [/[ \t]+/, ""],
+                // next G/M/T-code - replace this state with the code's own state so its parameters
+                // are parsed normally and any trailing T letters are treated as parameters, not T-codes
+                [/[gG][0123](?=\D)/, { token: "keyword", switchTo: fdmMode ? "@normalGcode" : "@moveGcode" }],
+                [/[gGmM]\d+(\.\d+)?/, { token: "keyword", switchTo: "@normalGcode" }],
+                [/[tT](?=\{)/, { token: "keyword", switchTo: "@normalGcodeWithT" }],
+                [/[tT]-?\d+/, { token: "keyword", switchTo: "@normalGcodeWithT" }]
+            ],
             gcode: [
-                // next G/M/T-code
-                [/[gG][0123](?=\D)/, "keyword", "moveGcode"],
-                [/[gGmM]\d+(\.\d*)?/, "keyword", "normalGcode"],
-                [/[tT](?=\{)/, "keyword", "normalGcodeWithT"],
-                [/[tT]-?\d+/, "keyword", "normalGcodeWithT"],
                 // checksums
                 [/\*\d+/, "type"],
                 // parameter letters
@@ -86,15 +99,27 @@ function generateMonarchLanguage(fdmMode) {
             expression: [
                 // variables
                 [/(global|param|var)\.[a-zA-Z_$][\w$]*/, "variable.name"],
-                // object model properties
-                [/\w+(\.\w+)*/, "variable"],
-                // consts and functions
+                // Member access after `]` or any other punctuator (e.g. `fans[1].max`): always a property name,
+                // not a function call - so it must win over the function rule below even if the member name
+                // happens to match a function identifier (`max`, `min`, ...).
+                [/(\.)([a-zA-Z_$][\w$]*)/, ["delimiter", "variable"]],
+                // consts and functions need to match before the generic identifier rule below, otherwise
+                // `cos` / `pi` / etc. get consumed as plain variables and never reach this check
+                // `support.function` is the TextMate scope used by VSCode's Dark+/Light+ themes for built-in
+                // function calls; Monaco's default themes have no rule for it, so our `registerDuetLanguages`
+                // theme overrides are unambiguously applied (yellow #DCDCAA dark / #795E26 light).
                 [/[a-z]\w*/, {
                         cases: {
                             "@consts": "constant",
-                            "@functions": "keyword"
+                            "@functions": "support.function",
+                            "@default": "variable"
                         }
                     }],
+                // object model properties with dotted paths (e.g. move.axes)
+                [/\w+(\.\w+)*/, "variable"],
+                // unterminated nested expressions
+                [/\{(?![^\n]*\})/, "invalid", "@unterminatedCurly"],
+                [/\[(?![^\n]*\])/, "invalid", "@unterminatedSquare"],
                 // unterminated nested expressions
                 [/\{(?![^\n]*\})/, "invalid", "@unterminatedCurly"],
                 [/\[(?![^\n]*\])/, "invalid", "@unterminatedSquare"],
@@ -153,8 +178,8 @@ function generateMonarchLanguage(fdmMode) {
                 [/\n/, "", "@popall"]
             ],
             varName: [
-                // variable name
-                [/[a-zA-Z_$][\w$]*/, "variable.name", "@expression"],
+                // variable name being declared by `var` / `global` - render as a parameter so the name stands out from generic identifier colour
+                [/[a-zA-Z_$][\w$]*/, "variable.parameter", "@expression"],
                 // EOL
                 [/\n/, "", "@popall"]
             ]
@@ -187,6 +212,7 @@ exports.gcodeLanguageConfiguration = {
     // Python-style block indentation: pressing Enter after if/elif/else/while indents the next line one level deeper
     indentationRules: {
         increaseIndentPattern: /^\s*(if|elif|else|while)\b.*$/,
-        decreaseIndentPattern: /^\s*(break|continue)\b.*$/
+        // `elif|else` dedent so they align with the matching `if`; `break|continue` end the surrounding while-block
+        decreaseIndentPattern: /^\s*(elif|else|break|continue)\b.*$/
     }
 };

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,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathDeprecation = getPathDeprecation;
+exports.getMemberDeprecation = getMemberDeprecation;
+const deprecations_json_1 = __importDefault(require("@duet3d/objectmodel/dist/deprecations.json"));
+const paths_1 = require("./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 = deprecations_json_1.default;
+/**
+ * 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.
+ */
+function getPathDeprecation(path) {
+    if (!path) {
+        return null;
+    }
+    const key = (0, paths_1.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.
+ */
+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,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumValuesForPath = getEnumValuesForPath;
+const enums_json_1 = __importDefault(require("@duet3d/objectmodel/dist/enums.json"));
+const paths_1 = require("./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 = enums_json_1.default;
+/**
+ * Return the list of valid values for a given object-model path, or null if the path has no known enum values.
+ */
+function getEnumValuesForPath(path) {
+    if (!path) {
+        return null;
+    }
+    const key = (0, paths_1.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,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMachineContext = setMachineContext;
+exports.getMachineContext = getMachineContext;
+exports.onMachineContextChange = onMachineContextChange;
+let current = null;
+const listeners = new Set();
+/**
+ * Set (or clear) the runtime machine context. Pass `null` when the machine is disconnected.
+ */
+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.
+ */
+function getMachineContext() {
+    return current;
+}
+/**
+ * Subscribe to machine-context changes. Returns an unsubscribe function.
+ */
+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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalisePath = normalisePath;
+/** 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. */
+function normalisePath(path) {
+    return path.replace(/\[\d+\]/g, "[]");
+}

package/dist/providers.d.ts

@@ -0,0 +1,55 @@
+import type * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+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;