@duet3d/monacotokens 3.6.1 → 3.6.2

package/dist/gcodes/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * One enumerated value of a parameter (e.g. "1" for G1 H meaning "Stop on endstop")
+ */
+export interface GcodeParameterValue {
+    /** Literal value as it appears in source (e.g. "0", "1", "-1") */
+    value: string;
+    /** Human-readable meaning */
+    description: string;
+}
+/**
+ * Description of one parameter letter that a G/M/T-code accepts
+ */
+export interface GcodeParameter {
+    /** Single uppercase parameter letter (e.g. "X", "S") */
+    letter: string;
+    /** Human-readable description shown in tooltips and completion items */
+    description: string;
+    /** Optional enumeration of valid values, rendered as a table in tooltips */
+    values?: GcodeParameterValue[];
+    /** If set, this parameter is deprecated; the string is shown as the reason (e.g. "Use M18 S<timeout> instead") */
+    deprecated?: string;
+}
+/**
+ * Description of a value that follows the code letter directly without a parameter letter (e.g. the tool
+ * number after T, the message after M117). Named after DSF's `UnprecedentedParameter` concept: the value
+ * has no parameter letter preceding it. Accepts literals, quoted strings, or `{...}` expressions.
+ */
+export interface GcodeUnprecedentedParameter {
+    /** Label shown in the signature, e.g. "<n>" */
+    label: string;
+    /** Description shown in the tooltip when this position is active */
+    description: string;
+}
+/**
+ * Description of one G/M/T-code (RRF dialect)
+ */
+export interface GcodeInfo {
+    /** Code identifier as it appears in source, e.g. "G1", "M104", "M203" */
+    code: string;
+    /** One-line summary shown in the completion dropdown and in hover headers */
+    summary: string;
+    /** Optional longer prose description shown above the parameter list in the signature-help doc panel */
+    description?: string;
+    /** Optional value that follows the code letter directly (e.g. the tool number for T, the message for M117) */
+    unprecedentedParameter?: GcodeUnprecedentedParameter;
+    /** Parameter letters this code understands */
+    parameters: GcodeParameter[];
+    /** If set, this code is deprecated; the string is shown as the reason */
+    deprecated?: string;
+}
+/**
+ * Curated dataset of G/M/T-codes used to drive Monaco completion and hover providers.
+ * Sourced from gcode-data.json so it can be regenerated automatically from an upstream reference (docs.duet3d.com or DuetScreen) without touching TypeScript.
+ */
+export declare const gcodeData: GcodeInfo[];
+/**
+ * Look up an entry by code. Accepts mixed-case ("g1", "M104", ...) by upper-casing the leading letter
+ * before matching against the canonical "G1" / "M104" / "T" form stored in gcodeData.
+ */
+export declare function findGcode(code: string): GcodeInfo | undefined;

package/dist/gcodes/index.js

@@ -0,0 +1,17 @@
+import gcodeDataJson from "./gcodes.json";
+/**
+ * Curated dataset of G/M/T-codes used to drive Monaco completion and hover providers.
+ * Sourced from gcode-data.json so it can be regenerated automatically from an upstream reference (docs.duet3d.com or DuetScreen) without touching TypeScript.
+ */
+export const gcodeData = gcodeDataJson;
+/**
+ * Look up an entry by code. Accepts mixed-case ("g1", "M104", ...) by upper-casing the leading letter
+ * before matching against the canonical "G1" / "M104" / "T" form stored in gcodeData.
+ */
+export function findGcode(code) {
+    if (!code) {
+        return undefined;
+    }
+    const canonical = code[0].toUpperCase() + code.substring(1);
+    return gcodeData.find(g => g.code === canonical);
+}

package/dist/gcodes/local-variables.d.ts

@@ -0,0 +1,26 @@
+import type * as monaco from "monaco-editor-core/esm/vs/editor/editor.api.js";
+/**
+ * Names declared inside the currently-edited model via RRF's meta language (`var foo = ...`, `global bar = ...`).
+ * Populated by `attachLocalVariableScanner(editor)` and consulted by the expression completion provider when
+ * the user types `var.` / `global.`.
+ */
+export interface LocalVariables {
+    /** `var <name>` declarations seen on any line of the model. */
+    readonly vars: ReadonlySet<string>;
+    /** `global <name>` declarations seen on any line of the model. */
+    readonly globals: ReadonlySet<string>;
+}
+/**
+ * Attach a background scanner that keeps track of `var` and `global` declarations in the given editor's model.
+ * Re-runs on every content change, debounced to avoid churn on large files. The result is consumed by the
+ * expression completion provider through `getLocalVariables(model)`.
+ *
+ * Scans up to `maxLines` lines (default 5000) - well beyond typical macro size but bounded for generated
+ * G-code exports that would otherwise pay a per-keystroke cost.
+ */
+export declare function attachLocalVariableScanner(editor: monaco.editor.IStandaloneCodeEditor, maxLines?: number): monaco.IDisposable;
+/**
+ * Return the most recently scanned `var`/`global` declarations for the given model, or empty sets if no
+ * scanner is attached (or the first scan hasn't completed yet).
+ */
+export declare function getLocalVariables(model: monaco.editor.ITextModel): LocalVariables;

package/dist/gcodes/local-variables.js

@@ -0,0 +1,62 @@
+/** Debounce delay for rescanning a model's `var` / `global` declarations on content change (ms). */
+const LOCAL_VARIABLE_RESCAN_DEBOUNCE_MS = 250;
+const empty = { vars: new Set(), globals: new Set() };
+// WeakMap so dispose is automatic when Monaco's model is garbage-collected
+const scans = new WeakMap();
+// Matches `var name`, `global name` optionally followed by `=` (trailing assignment not required for the capture)
+const declRegex = /^\s*(var|global)\s+([A-Za-z_][\w]*)/;
+function scan(model, maxLines) {
+    const vars = new Set();
+    const globals = new Set();
+    const lineCount = Math.min(model.getLineCount(), maxLines);
+    for (let line = 1; line <= lineCount; line++) {
+        const text = model.getLineContent(line);
+        const m = declRegex.exec(text);
+        if (m) {
+            (m[1] === "var" ? vars : globals).add(m[2]);
+        }
+    }
+    return { vars, globals };
+}
+/**
+ * Attach a background scanner that keeps track of `var` and `global` declarations in the given editor's model.
+ * Re-runs on every content change, debounced to avoid churn on large files. The result is consumed by the
+ * expression completion provider through `getLocalVariables(model)`.
+ *
+ * Scans up to `maxLines` lines (default 5000) - well beyond typical macro size but bounded for generated
+ * G-code exports that would otherwise pay a per-keystroke cost.
+ */
+export function attachLocalVariableScanner(editor, maxLines = 5000) {
+    let timeout = null;
+    const rescan = () => {
+        const model = editor.getModel();
+        if (model) {
+            scans.set(model, scan(model, maxLines));
+        }
+    };
+    const schedule = () => {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(rescan, LOCAL_VARIABLE_RESCAN_DEBOUNCE_MS);
+    };
+    rescan();
+    const contentListener = editor.onDidChangeModelContent(schedule);
+    const modelListener = editor.onDidChangeModel(rescan);
+    return {
+        dispose: () => {
+            if (timeout !== null) {
+                clearTimeout(timeout);
+            }
+            contentListener.dispose();
+            modelListener.dispose();
+        }
+    };
+}
+/**
+ * Return the most recently scanned `var`/`global` declarations for the given model, or empty sets if no
+ * scanner is attached (or the first scan hasn't completed yet).
+ */
+export function getLocalVariables(model) {
+    return scans.get(model) ?? empty;
+}

package/dist/gcodes/search.d.ts

@@ -0,0 +1,17 @@
+import type * as monaco from "monaco-editor-core/esm/vs/editor/editor.api.js";
+/**
+ * Open the gcode search overlay anchored to the current cursor position, styled like the F2 rename widget.
+ */
+export declare function showGcodeSearch(monacoInstance: typeof monaco, editor: monaco.editor.IStandaloneCodeEditor): void;
+/**
+ * Open a variant of the search overlay that lists object-model paths instead of G/M-codes. The model is
+ * flattened once on open (up to depth 3) and cached in the widget for the duration of the session; arrays
+ * are represented by their first element with an `[0]` placeholder. Local `var` / `global` declarations
+ * scanned from the current editor model are folded in as `var.<name>` / `global.<name>` entries.
+ */
+export declare function showObjectModelSearch(monacoInstance: typeof monaco, editor: monaco.editor.IStandaloneCodeEditor): void;
+/**
+ * Register the F4 search action on a freshly created editor instance.
+ * Call this once per editor right after `monaco.editor.create(...)`.
+ */
+export declare function addGcodeSearchAction(monacoInstance: typeof monaco, editor: monaco.editor.IStandaloneCodeEditor): monaco.IDisposable;