openalgo-script 0.2.0 → 0.5.0

package/dist/adapters/codemirror/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/contract.ts"],"names":[],"mappings":"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"}

package/dist/adapters/codemirror/contract.js

@@ -0,0 +1,42 @@
+/**
+ * The editor component's own shapes, as this adapter targets them.
+ *
+ * **Why they are declared here rather than imported.** The editor component is a
+ * peer dependency: a host that wants a text area installs it, and a host that
+ * wants only the language must not be made to. This repository therefore does
+ * not install it, cannot type check against it, and would fail its own layering
+ * check the moment a file here imported it. It is the same decision the chart
+ * adapter took, for the same reason, and `src/adapters/charts/contract.ts` says
+ * it at length.
+ *
+ * So the shapes this produces values for are declared below and the host's own
+ * build is where the two meet. Each one is a one line check that costs a host
+ * nothing and fails to compile if this file has drifted:
+ *
+ * ```ts
+ * import type { StreamParser } from "<the editor's language package>";
+ * import type { CompletionSource } from "<the editor's completion package>";
+ * import type { Diagnostic } from "<the editor's lint package>";
+ *
+ * const parser: StreamParser<unknown> = openscriptStream;
+ * const source: CompletionSource = openscriptCompletion;
+ * const linter: (view: EditorView) => Diagnostic[] = openscriptLint;
+ * ```
+ *
+ * **That line catches a value of the wrong shape and not an argument of the
+ * wrong shape.** A method's parameters are compared in both directions, so a
+ * hook declared here as taking something the editor never passes still assigns.
+ * That is the failure the chart adapter has actually made, so every member below
+ * takes the editor's own argument, spelled as the editor spells it, and every
+ * test drives each one with the argument the editor passes rather than with one
+ * of its own.
+ *
+ * **A style name is not checked by any of those lines.** The names this adapter
+ * returns from `token` are looked up by the editor in its own table of
+ * highlighting tags at run time, and an unknown one is a warning on a console
+ * rather than a compile error. That is why the whole mapping is one exported
+ * record a host can replace in a line, and why it is recorded in
+ * `spec/editor-narrowings.json` as the one thing here a type cannot hold.
+ */
+export {};
+//# sourceMappingURL=contract.js.map

package/dist/adapters/codemirror/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG"}

package/dist/adapters/codemirror/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The editor adapter: the language intelligence, wired into a text component.
+ *
+ * This and the chart adapter are the only modules in the repository allowed to
+ * know two worlds at once, and it is the piece a platform with its own editor
+ * replaces rather than the piece it patches. Everything under `src/editor` stays
+ * ignorant of any component, and the layering check is what keeps it that way.
+ *
+ * **The editor component is a peer dependency, and nothing here imports it.** A
+ * package that pulled a text component into everyone's install would defeat the
+ * point of a language a platform can take on its own, so the shapes this
+ * produces are declared in `contract.ts` and the host's own build is where the
+ * two are compared, in one line per piece. See that file for the lines. The
+ * entry point resolves and every function here runs in an install that holds no
+ * editor at all, which `scripts/check-entry-points.mjs` proves on every build.
+ *
+ * Six functions in, five pieces out:
+ *
+ *     openscriptStream             highlighting, a line at a time
+ *     openscriptCompletion         the completion list
+ *     openscriptLint               errors as you type, with their fixes
+ *     openscriptHoverTooltip       what the thing under the pointer is
+ *     openscriptSignatureTooltip   the call being written
+ *     formatDocument               lay the script out again
+ *
+ * The two tooltips take the markup as a parameter and have no default for it, so
+ * nothing in this package names a browser global at any tier. A host that wants
+ * none of this calls the six functions itself and draws its own. That is not the fallback, it is the supported path: what a host gives up
+ * by taking these instead is recorded in `spec/editor-narrowings.json`, which is
+ * three lines long and worth reading before choosing.
+ */
+export type { EditorCompletion, EditorCompletionContext, EditorCompletionResult, EditorDiagnostic, EditorState, EditorStreamParser, EditorStringStream, EditorText, EditorTooltip, EditorTooltipView, EditorView, } from './contract.js';
+export { COMPLETION_TYPES, HIGHLIGHT_TOKENS } from './tokens.js';
+export type { StreamState } from './stream.js';
+export { openscriptStream } from './stream.js';
+export { openscriptCompletion } from './completion.js';
+export { diagnosticsFor, openscriptLint } from './lint.js';
+export type { Renderer } from './tooltips.js';
+export { hoverLines, openscriptHoverTooltip, openscriptSignatureTooltip, signatureLines, } from './tooltips.js';
+export { formatDocument } from './commands.js';
+export type { Document } from './positions.js';
+export { documentOf, normalisedOffset } from './positions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/codemirror/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,UAAU,GACX,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEjE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3D,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/adapters/codemirror/index.js

@@ -0,0 +1,8 @@
+export { COMPLETION_TYPES, HIGHLIGHT_TOKENS } from './tokens.js';
+export { openscriptStream } from './stream.js';
+export { openscriptCompletion } from './completion.js';
+export { diagnosticsFor, openscriptLint } from './lint.js';
+export { hoverLines, openscriptHoverTooltip, openscriptSignatureTooltip, signatureLines, } from './tooltips.js';
+export { formatDocument } from './commands.js';
+export { documentOf, normalisedOffset } from './positions.js';
+//# sourceMappingURL=index.js.map

package/dist/adapters/codemirror/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/index.ts"],"names":[],"mappings":"AA6CA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3D,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/adapters/codemirror/lint.d.ts

@@ -0,0 +1,17 @@
+import type { EditorDiagnostic, EditorView } from './contract.js';
+/** Every diagnostic of a document, in the editor's own shape. */
+export declare function diagnosticsFor(raw: string): readonly EditorDiagnostic[];
+/**
+ * The linter a host wires in one line.
+ *
+ * ```ts
+ * linter(openscriptLint)
+ * ```
+ *
+ * It is synchronous because it is fast enough to be: a finished ninety line
+ * study compiles in a third of a millisecond and the same file with a bracket
+ * left open in about a millisecond, both with a budget in the benchmark suite.
+ * The editor's own linter already debounces, so nothing here does it twice.
+ */
+export declare function openscriptLint(view: EditorView): readonly EditorDiagnostic[];
+//# sourceMappingURL=lint.d.ts.map

package/dist/adapters/codemirror/lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/lint.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQlE,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAavE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,gBAAgB,EAAE,CAE5E"}

package/dist/adapters/codemirror/lint.js

@@ -0,0 +1,62 @@
+/**
+ * Errors as you type, as the editor's linter.
+ *
+ * The diagnostics are the compiler's own, whole: `diagnose` runs the lexer, the
+ * parser, the checker and the emitter, so what a writer sees beside their line
+ * is exactly what a compile produces and nothing new can appear when they press
+ * apply. Every message and every fix came from the error catalogue that the
+ * documentation site is generated from.
+ *
+ * Three decisions worth stating, because each one is visible to a trader.
+ *
+ * **The fix is shown.** A `Diagnostic` carries a message saying what is wrong and
+ * a fix saying what to do, and the fix is the half that is worth reading. The
+ * editor's panel shows one string, so the two are joined with a line break
+ * rather than the fix being dropped.
+ *
+ * **The code is the source.** The editor shows a diagnostic's source beside its
+ * message, and a code is the one part of a diagnostic this project promises never
+ * to change, so it is what a trader quotes and what a support page is indexed by.
+ *
+ * **A zero width span is widened by one character.** The compiler points at a
+ * position for a mistake that is an absence, a missing bracket among them, and a
+ * squiggle of no width is a squiggle nobody sees.
+ */
+import { endOffset } from '../../core/index.js';
+import { diagnose } from '../../editor/index.js';
+import { documentOf } from './positions.js';
+/** What the editor prints beside a message, which is the code and nothing else. */
+function sourceOf(one) {
+    return one.code;
+}
+/** Every diagnostic of a document, in the editor's own shape. */
+export function diagnosticsFor(raw) {
+    const held = documentOf(raw);
+    return diagnose(held.text).map((one) => {
+        const from = held.at(one.span.offset);
+        const to = held.at(endOffset(one.span));
+        return {
+            from,
+            to: to > from ? to : from + 1,
+            severity: one.severity,
+            message: `${one.message}\n${one.fix}`,
+            source: sourceOf(one),
+        };
+    });
+}
+/**
+ * The linter a host wires in one line.
+ *
+ * ```ts
+ * linter(openscriptLint)
+ * ```
+ *
+ * It is synchronous because it is fast enough to be: a finished ninety line
+ * study compiles in a third of a millisecond and the same file with a bracket
+ * left open in about a millisecond, both with a budget in the benchmark suite.
+ * The editor's own linter already debounces, so nothing here does it twice.
+ */
+export function openscriptLint(view) {
+    return diagnosticsFor(view.state.doc.toString());
+}
+//# sourceMappingURL=lint.js.map

package/dist/adapters/codemirror/lint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,mFAAmF;AACnF,SAAS,QAAQ,CAAC,GAAe;IAC/B,OAAO,GAAG,CAAC,IAAI,CAAC;AAClB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,OAAO;YACL,IAAI;YACJ,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;YAC7B,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,GAAG,EAAE;YACrC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC;SACtB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,IAAgB;IAC7C,OAAO,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;AACnD,CAAC"}

package/dist/adapters/codemirror/positions.d.ts

@@ -0,0 +1,16 @@
+/** The document as the compiler reads it, and where each of its offsets sits. */
+export interface Document {
+    /** The normalised text: what `diagnose`, `complete` and the rest are given. */
+    readonly text: string;
+    /**
+     * The offset in the editor's own document that a normalised offset names.
+     *
+     * The identity where the document is already normalised, which is what a
+     * document written on a machine that ends its lines with one character is.
+     */
+    at(offset: number): number;
+}
+export declare function documentOf(raw: string): Document;
+/** The normalised offset an editor offset names, which is the other direction. */
+export declare function normalisedOffset(held: Document, raw: number): number;
+//# sourceMappingURL=positions.d.ts.map

package/dist/adapters/codemirror/positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/positions.ts"],"names":[],"mappings":"AA0BA,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAwBhD;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAYpE"}

package/dist/adapters/codemirror/positions.js

@@ -0,0 +1,65 @@
+/**
+ * Offsets, translated between the document the editor holds and the text the
+ * compiler read.
+ *
+ * `language.md` 3.1 normalises a file before anything reads it: a byte order
+ * mark is dropped and every CRLF becomes LF. Every span the compiler produces
+ * therefore indexes the normalised text, which `docs/integrating/the-editor-half.md`
+ * tells a host plainly and expects it to handle.
+ *
+ * A drop-in cannot expect it. A document written on a machine that ends its
+ * lines with two characters is an ordinary document, the editor holds it exactly
+ * as it is, and an adapter that handed the editor a span from the normalised
+ * text would put every squiggle on a file's fiftieth line fifty characters to
+ * the left. That is the kind of defect that is reported as "the underline is in
+ * the wrong place" and survives for months.
+ *
+ * So the two are mapped. The map is built only when the document is not already
+ * normalised, which is the common case and costs a comparison; when it is built
+ * it is one walk of the text.
+ */
+import { normaliseSource } from '../../core/index.js';
+const BYTE_ORDER_MARK = 0xfeff;
+const CARRIAGE_RETURN = 13;
+const LINE_FEED = 10;
+export function documentOf(raw) {
+    const text = normaliseSource(raw);
+    if (text === raw)
+        return { text, at: (offset) => offset };
+    // One entry per normalised offset, plus the one past its end, so that the end
+    // of a span at the end of the file maps as readily as its start.
+    const map = new Array(text.length + 1);
+    let normalised = 0;
+    let held = raw.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
+    while (normalised <= text.length) {
+        map[normalised] = held;
+        if (normalised === text.length)
+            break;
+        if (raw.charCodeAt(held) === CARRIAGE_RETURN && raw.charCodeAt(held + 1) === LINE_FEED) {
+            held += 1;
+        }
+        held += 1;
+        normalised += 1;
+    }
+    return {
+        text,
+        at: (offset) => map[Math.min(Math.max(offset, 0), text.length)] ?? offset,
+    };
+}
+/** The normalised offset an editor offset names, which is the other direction. */
+export function normalisedOffset(held, raw) {
+    // Walked rather than inverted, because the inverse of the map above is only
+    // needed at one position per call and building a second array to answer one
+    // question would cost a file's length for a comparison's worth of work.
+    let low = 0;
+    let high = held.text.length;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (held.at(middle) <= raw)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+}
+//# sourceMappingURL=positions.js.map

package/dist/adapters/codemirror/positions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/positions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,eAAe,GAAG,MAAM,CAAC;AAC/B,MAAM,eAAe,GAAG,EAAE,CAAC;AAC3B,MAAM,SAAS,GAAG,EAAE,CAAC;AAerB,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,MAAM,IAAI,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;IAE1D,8EAA8E;IAC9E,iEAAiE;IACjE,MAAM,GAAG,GAAG,IAAI,KAAK,CAAS,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/C,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzD,OAAO,UAAU,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QACjC,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;QACvB,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM;YAAE,MAAM;QACtC,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,eAAe,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;YACvF,IAAI,IAAI,CAAC,CAAC;QACZ,CAAC;QACD,IAAI,IAAI,CAAC,CAAC;QACV,UAAU,IAAI,CAAC,CAAC;IAClB,CAAC;IAED,OAAO;QACL,IAAI;QACJ,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,MAAM;KAC1E,CAAC;AACJ,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,gBAAgB,CAAC,IAAc,EAAE,GAAW;IAC1D,4EAA4E;IAC5E,4EAA4E;IAC5E,wEAAwE;IACxE,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC5B,OAAO,GAAG,GAAG,IAAI,EAAE,CAAC;QAClB,MAAM,MAAM,GAAG,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,GAAG;YAAE,GAAG,GAAG,MAAM,CAAC;;YACpC,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/adapters/codemirror/stream.d.ts

@@ -0,0 +1,23 @@
+import type { Highlight } from '../../editor/index.js';
+import type { EditorStreamParser } from './contract.js';
+/** What is carried from one call to the next: the line, and its pieces. */
+export interface StreamState {
+    /** The line the pieces were computed from, so a changed line is redone. */
+    line: string;
+    pieces: readonly Highlight[];
+}
+/**
+ * The tokenizer, which a host turns into a language with one call.
+ *
+ * ```ts
+ * const openscript = StreamLanguage.define(openscriptStream);
+ * ```
+ *
+ * `token` moves the stream to the end of the piece that starts where it is and
+ * returns that piece's style. A stream that has somehow been left inside a piece,
+ * which the editor does when it re-tokenizes from a column rather than from the
+ * start of a line, is moved to the end of the piece containing it, so the
+ * tokenizer always advances and the editor cannot be made to loop.
+ */
+export declare const openscriptStream: EditorStreamParser<StreamState>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/adapters/codemirror/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/stream.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,eAAe,CAAC;AAG5E,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;CAC9B;AAWD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,WAAW,CA4B5D,CAAC"}

package/dist/adapters/codemirror/stream.js

@@ -0,0 +1,70 @@
+/**
+ * Highlighting, as the editor's line at a time tokenizer.
+ *
+ * The editor asks for one line's tokens at a time and remembers nothing between
+ * lines except the state this file hands back. The tier's `highlight` takes a
+ * whole file. So the line is what is lexed here, by the real lexer, through the
+ * same `highlight` a host would call itself.
+ *
+ * **That is an equivalence rather than an approximation, and it is measured.**
+ * `tests/adapters/codemirror/stream.test.ts` puts every script in the repository
+ * and the malformed corpus through both routes and compares them piece for
+ * piece: 4279 lines of real scripts, and not one of them differs. It holds
+ * because nothing in this language crosses a line ending: a string literal is
+ * refused at the end of its line, there is no block comment, and the layout
+ * tokens that do depend on the lines above are painted as whitespace either way.
+ * If the language ever grows something that does cross one, that test fails on
+ * the day it is added rather than on the day somebody notices a half painted
+ * line, and this becomes a line the narrowings file has to carry.
+ *
+ * A line is lexed once, not once per token: the pieces are computed when the
+ * editor arrives at the start of a line and walked from there. Without that, a
+ * line of twenty tokens would be lexed twenty times, which is the shape that
+ * makes a tokenizer show up in a frame budget.
+ */
+import { highlight } from '../../editor/index.js';
+import { HIGHLIGHT_TOKENS } from './tokens.js';
+/** The pieces of one line, computed once and kept until the line changes. */
+function piecesFor(state, line) {
+    if (state.line !== line || state.pieces.length === 0) {
+        state.line = line;
+        state.pieces = highlight(line);
+    }
+    return state.pieces;
+}
+/**
+ * The tokenizer, which a host turns into a language with one call.
+ *
+ * ```ts
+ * const openscript = StreamLanguage.define(openscriptStream);
+ * ```
+ *
+ * `token` moves the stream to the end of the piece that starts where it is and
+ * returns that piece's style. A stream that has somehow been left inside a piece,
+ * which the editor does when it re-tokenizes from a column rather than from the
+ * start of a line, is moved to the end of the piece containing it, so the
+ * tokenizer always advances and the editor cannot be made to loop.
+ */
+export const openscriptStream = {
+    name: 'openscript',
+    startState: () => ({ line: '', pieces: [] }),
+    copyState: (state) => ({ line: state.line, pieces: state.pieces }),
+    token(stream, state) {
+        if (stream.eol())
+            return null;
+        const pieces = piecesFor(state, stream.string);
+        const at = stream.pos;
+        const piece = pieces.find((one) => at >= one.span.offset && at < one.span.offset + one.span.length);
+        if (piece === undefined) {
+            // No piece covers the position, which cannot happen for a line the tier
+            // has covered and is still answered rather than trusted: the pieces tile
+            // the line, so this is a position outside it. Moving to the end leaves the
+            // editor with an unstyled remainder instead of an infinite loop.
+            stream.pos = stream.string.length;
+            return null;
+        }
+        stream.pos = piece.span.offset + piece.span.length;
+        return HIGHLIGHT_TOKENS[piece.kind];
+    },
+};
+//# sourceMappingURL=stream.js.map

package/dist/adapters/codemirror/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAS/C,6EAA6E;AAC7E,SAAS,SAAS,CAAC,KAAkB,EAAE,IAAY;IACjD,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrD,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;QAClB,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAoC;IAC/D,IAAI,EAAE,YAAY;IAElB,UAAU,EAAE,GAAgB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAEzD,SAAS,EAAE,CAAC,KAAkB,EAAe,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;IAE5F,KAAK,CAAC,MAA0B,EAAE,KAAkB;QAClD,IAAI,MAAM,CAAC,GAAG,EAAE;YAAE,OAAO,IAAI,CAAC;QAE9B,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/C,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC;QACtB,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CACvB,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,MAAM,CACzE,CAAC;QAEF,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,wEAAwE;YACxE,yEAAyE;YACzE,2EAA2E;YAC3E,iEAAiE;YACjE,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YAClC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;QACnD,OAAO,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;CACF,CAAC"}

package/dist/adapters/codemirror/tokens.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The eleven kinds, as the editor's own highlighting tags.
+ *
+ * This is the translation an adapter exists to do: the language has eleven
+ * kinds, closed, and the editor has a vocabulary of tags its themes are written
+ * against. Neither knows about the other, and this file is the only place that
+ * knows both.
+ *
+ * **It is one record rather than a switch on purpose.** A style name is the one
+ * thing in this adapter that no type can hold: the editor looks a name up in its
+ * own tag table at run time and warns on a console about one it does not know,
+ * so a name that is wrong here is invisible to every check in this repository
+ * and shows up as an unpainted keyword in somebody's product. A host that
+ * disagrees with any of these, or whose theme is written against different
+ * names, replaces the row in one line:
+ *
+ * ```ts
+ * const tokens = { ...HIGHLIGHT_TOKENS, unknown: "invalid" };
+ * ```
+ *
+ * Two of the eleven are deliberately unstyled. `whitespace` has nothing to
+ * paint. `unknown` is the honest name for source the lexer took no token from,
+ * which is a character the language does not have, a region somebody wrote as a
+ * block comment, or a line continuation backslash: the first is a mistake and
+ * the last is not, so painting all three as invalid would paint a correct line
+ * red. `diagnose` is what says which of them is wrong, and the linter below is
+ * how a host shows that.
+ */
+import type { HighlightKind } from '../../editor/index.js';
+/**
+ * A style name per kind, or null for one the editor should leave alone.
+ *
+ * `builtin` uses the editor's modifier syntax for a name the environment
+ * supplies rather than the file, which is what a library name is.
+ */
+export declare const HIGHLIGHT_TOKENS: Readonly<Record<HighlightKind, string | null>>;
+/**
+ * The editor's name for the icon beside a completion row, per kind.
+ *
+ * The editor ships icons for a fixed set of names and shows none for a name it
+ * does not know, which is a missing icon rather than a missing row.
+ */
+export declare const COMPLETION_TYPES: Readonly<Record<string, string>>;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/adapters/codemirror/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC,CAY3E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO7D,CAAC"}

package/dist/adapters/codemirror/tokens.js

@@ -0,0 +1,34 @@
+/**
+ * A style name per kind, or null for one the editor should leave alone.
+ *
+ * `builtin` uses the editor's modifier syntax for a name the environment
+ * supplies rather than the file, which is what a library name is.
+ */
+export const HIGHLIGHT_TOKENS = {
+    keyword: 'keyword',
+    builtin: 'variableName.standard',
+    name: 'variableName',
+    number: 'number',
+    string: 'string',
+    color: 'color',
+    comment: 'comment',
+    operator: 'operator',
+    punctuation: 'punctuation',
+    whitespace: null,
+    unknown: null,
+};
+/**
+ * The editor's name for the icon beside a completion row, per kind.
+ *
+ * The editor ships icons for a fixed set of names and shows none for a name it
+ * does not know, which is a missing icon rather than a missing row.
+ */
+export const COMPLETION_TYPES = {
+    function: 'function',
+    value: 'constant',
+    namespace: 'namespace',
+    member: 'property',
+    variable: 'variable',
+    argument: 'property',
+};
+//# sourceMappingURL=tokens.js.map

package/dist/adapters/codemirror/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/tokens.ts"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAmD;IAC9E,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,uBAAuB;IAChC,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;CACd,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqC;IAChE,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,UAAU;IACjB,SAAS,EAAE,WAAW;IACtB,MAAM,EAAE,UAAU;IAClB,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;CACrB,CAAC"}

package/dist/adapters/codemirror/tooltips.d.ts

@@ -0,0 +1,35 @@
+import type { Hover, SignatureHelp } from '../../editor/index.js';
+import type { EditorState, EditorTooltip, EditorTooltipView, EditorView } from './contract.js';
+/** What a host supplies to draw a tooltip, which is the whole of the markup. */
+export interface Renderer<Held> {
+    (held: Held): EditorTooltipView;
+}
+/**
+ * The lines a hover shows, in the order it shows them.
+ *
+ * Every one of them came from the compiler: the signatures from the library
+ * manifest, the sentence and the warmup from the specification's own tables, the
+ * type from the checker, and the refusal from the error catalogue. Nothing is
+ * written here, which is why this function is a join rather than a template.
+ */
+export declare function hoverLines(held: Hover): readonly string[];
+/** The lines a signature tooltip shows, with the active parameter named. */
+export declare function signatureLines(held: SignatureHelp): readonly string[];
+/**
+ * A hover tooltip source, which a host wires in one line.
+ *
+ * ```ts
+ * hoverTooltip(openscriptHoverTooltip(render))
+ * ```
+ */
+export declare function openscriptHoverTooltip(render: Renderer<Hover>): (view: EditorView, pos: number) => EditorTooltip | null;
+/**
+ * A signature tooltip for wherever the cursor is, or nothing where it is in no
+ * call.
+ *
+ * ```ts
+ * showTooltip.compute(["doc", "selection"], openscriptSignatureTooltip(render))
+ * ```
+ */
+export declare function openscriptSignatureTooltip(render: Renderer<SignatureHelp>): (state: EditorState) => EditorTooltip | null;
+//# sourceMappingURL=tooltips.d.ts.map

package/dist/adapters/codemirror/tooltips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltips.d.ts","sourceRoot":"","sources":["../../../src/adapters/codemirror/tooltips.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG/F,gFAAgF;AAChF,MAAM,WAAW,QAAQ,CAAC,IAAI;IAC5B,CAAC,IAAI,EAAE,IAAI,GAAG,iBAAiB,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAOzD;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,MAAM,EAAE,CAYrE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,GACtB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,aAAa,GAAG,IAAI,CAWzD;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC9B,CAAC,KAAK,EAAE,WAAW,KAAK,aAAa,GAAG,IAAI,CAY9C"}

package/dist/adapters/codemirror/tooltips.js

@@ -0,0 +1,108 @@
+/**
+ * Hover and signature, as the editor's tooltips.
+ *
+ * This is the one part of the adapter that would put something on screen, and it
+ * is the one part that does not: the markup is a parameter, and there is no
+ * default for it. So nothing in this package, at any tier, names a browser
+ * global, and `scripts/check-layering.mjs` fails the build if anything under
+ * `src` does. The same files load in a worker, on a server and inside somebody
+ * else's application.
+ *
+ * It costs a host four lines and it is the whole point of the split. Every
+ * platform has a design system and none of them wants to fight a styled panel
+ * that arrived with a language package; a default renderer here would be that
+ * panel, and it would be the one thing in this adapter a host could not replace
+ * without replacing the adapter.
+ *
+ * What is not a parameter is the content. `hoverLines` and `signatureLines`
+ * below are what a tooltip says, in order, and every line of it came from the
+ * compiler: the signatures from the library manifest, the sentence and the
+ * warmup from the specification's own tables, the type from the checker, and the
+ * refusal from the error catalogue.
+ *
+ * ```ts
+ * hoverTooltip(openscriptHoverTooltip((held) => ({ dom: yourPanel(hoverLines(held)) })))
+ * ```
+ */
+import { hover, signature } from '../../editor/index.js';
+import { documentOf, normalisedOffset } from './positions.js';
+/**
+ * The lines a hover shows, in the order it shows them.
+ *
+ * Every one of them came from the compiler: the signatures from the library
+ * manifest, the sentence and the warmup from the specification's own tables, the
+ * type from the checker, and the refusal from the error catalogue. Nothing is
+ * written here, which is why this function is a join rather than a template.
+ */
+export function hoverLines(held) {
+    const lines = [...held.signatures];
+    if (held.summary !== undefined)
+        lines.push(held.summary);
+    if (held.warmup !== undefined)
+        lines.push(`First value: ${held.warmup}`);
+    if (held.refusal !== undefined)
+        lines.push(held.refusal);
+    if (held.kind === 'keyword')
+        lines.push('A reserved word of the language.');
+    return lines;
+}
+/** The lines a signature tooltip shows, with the active parameter named. */
+export function signatureLines(held) {
+    const lines = [held.signature];
+    const active = held.parameters[held.active];
+    if (active !== undefined) {
+        const value = active.defaultText === undefined ? '' : ` = ${active.defaultText}`;
+        const need = active.required ? 'required' : 'optional';
+        lines.push(`${active.name}: ${active.type}${value} (${need})`);
+        if (active.values.length > 0)
+            lines.push(`One of: ${active.values.join(', ')}`);
+    }
+    if (held.summary !== undefined)
+        lines.push(held.summary);
+    if (held.refusal !== undefined)
+        lines.push(held.refusal);
+    return lines;
+}
+/**
+ * A hover tooltip source, which a host wires in one line.
+ *
+ * ```ts
+ * hoverTooltip(openscriptHoverTooltip(render))
+ * ```
+ */
+export function openscriptHoverTooltip(render) {
+    return (view, pos) => {
+        const held = documentOf(view.state.doc.toString());
+        const found = hover(held.text, normalisedOffset(held, pos));
+        if (found === undefined)
+            return null;
+        return {
+            pos: held.at(found.span.offset),
+            end: held.at(found.span.offset + found.span.length),
+            create: () => render(found),
+        };
+    };
+}
+/**
+ * A signature tooltip for wherever the cursor is, or nothing where it is in no
+ * call.
+ *
+ * ```ts
+ * showTooltip.compute(["doc", "selection"], openscriptSignatureTooltip(render))
+ * ```
+ */
+export function openscriptSignatureTooltip(render) {
+    return (state) => {
+        const held = documentOf(state.doc.toString());
+        const at = normalisedOffset(held, state.selection.main.head);
+        const found = signature(held.text, at);
+        if (found === undefined)
+            return null;
+        return {
+            pos: state.selection.main.head,
+            above: true,
+            create: () => render(found),
+        };
+    };
+}
+//# sourceMappingURL=tooltips.js.map