openalgo-script 0.2.0 → 0.5.0

package/dist/editor/manifest.js

@@ -0,0 +1,93 @@
+/**
+ * The standard library manifest, as the three functions that read it need it.
+ *
+ * `complete`, `hover` and `signature` all want the same things about a name:
+ * which signature the writer means, how to spell that signature, what each
+ * parameter defaults to, and the line the specification gives it. Every one of
+ * those is a question the compiler already answers, and the whole value of this
+ * file is that it asks rather than knows.
+ *
+ *     which entries a name has    the manifest index, `libraryEntries`
+ *     what a parameter defaults   the manifest, or the emitter for the eight
+ *                                 declaration calls
+ *     what the call is for        `proseFor`, read out of `stdlib.md`'s own
+ *                                 tables at build time, with the warmup its row
+ *                                 states beside it
+ *     what a type is called       `typeText`, the checker's own spelling
+ *
+ * A list of function names typed into this repository would be right on the day
+ * it was typed and wrong at the next release, and a missing completion looks
+ * exactly like a completion that has not loaded yet, so nobody would report it.
+ *
+ * ## The default is the compiler's, including for the eight that hide it
+ *
+ * Most calls carry their default in the manifest, spelled as `stdlib.md` prints
+ * it. A `plot`, a `level`, a `table` and the five like them do not: their
+ * optional arguments become fields of a declaration rather than arguments an
+ * engine is passed, so their values live in the emitter
+ * (`compiled-program.md` 2.3). A tooltip built on the manifest alone would show
+ * a writer nothing beside `width?` while the compiler writes 1.5.
+ *
+ * So both are read, through `declarationDefaultText`, which is the same answer
+ * `scripts/check-defaults.mjs` holds to what the specification prints. A default
+ * shown here cannot differ from the one the compiler applies without failing the
+ * build, which is the only way a tooltip's number is worth anything.
+ */
+import { DECLARATION_CALLS, declarationDefaultText, libraryEntries, typeText, } from '../core/index.js';
+/** Every parameter of one signature, with the defaults from both homes. */
+export function parametersOf(entry) {
+    const declared = DECLARATION_CALLS.has(entry.name);
+    return entry.parameters.map((one) => ({
+        name: one.name,
+        type: typeText(one.type),
+        required: !one.optional,
+        defaultText: declared
+            ? declarationDefaultText(entry.name, one.name)
+            : one.defaultText,
+        values: entry.values[one.name] ?? [],
+    }));
+}
+/**
+ * One signature, written out the way the specification's tables write one.
+ *
+ * `ema(src: series number, len: number) -> series number`. The parameter names,
+ * the types and the defaults are the manifest's; nothing about the spelling is
+ * decided here except the punctuation between them.
+ */
+export function signatureTextOf(entry) {
+    if (!entry.callable)
+        return `${entry.name}: ${typeText(entry.returns)}`;
+    const written = parametersOf(entry).map((one) => {
+        const head = `${one.name}${one.required ? '' : '?'}: ${one.type}`;
+        return one.defaultText === undefined ? head : `${head} = ${one.defaultText}`;
+    });
+    return `${entry.name}(${written.join(', ')}) -> ${typeText(entry.returns)}`;
+}
+/**
+ * The signature a half written call means, chosen by the rule that can be
+ * applied to a half written call.
+ *
+ * `stdlib.md` 2.2 resolves an overload by arity first and by argument type
+ * second, and the checker does exactly that. The second rule needs a type for
+ * every argument, which needs a tree, which a call that is still being typed has
+ * not got: `clear(` is two signatures until the argument arrives. So only the
+ * first rule is applied here, and where it leaves more than one candidate the
+ * first is taken, which is the order `stdlib.md` states them in.
+ *
+ * That is a narrowing of the checker's answer rather than a second opinion about
+ * it: the tooltip may show the array signature of `clear` while the writer meant
+ * the grid one, and the moment the argument is written the checker settles it
+ * and `diagnose` is what says so. It is recorded in `spec/editor-narrowings.json`.
+ */
+export function entryAt(name, given) {
+    const entries = libraryEntries(name).filter((one) => one.callable);
+    const first = entries[0];
+    if (first === undefined || entries.length === 1)
+        return first;
+    const byArity = entries.filter((one) => {
+        const required = one.parameters.filter((parameter) => !parameter.optional).length;
+        return given >= required && given <= one.parameters.length;
+    });
+    return byArity[0] ?? first;
+}
+//# sourceMappingURL=manifest.js.map

package/dist/editor/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/editor/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAsB1B,2EAA2E;AAC3E,MAAM,UAAU,YAAY,CAAC,KAAmB;IAC9C,MAAM,QAAQ,GAAG,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnD,OAAO,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACpC,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;QACxB,QAAQ,EAAE,CAAC,GAAG,CAAC,QAAQ;QACvB,WAAW,EAAE,QAAQ;YACnB,CAAC,CAAC,sBAAsB,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC;YAC9C,CAAC,CAAC,GAAG,CAAC,WAAW;QACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE;KACrC,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,KAAmB;IACjD,IAAI,CAAC,KAAK,CAAC,QAAQ;QAAE,OAAO,GAAG,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;IACxE,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QAC9C,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,IAAI,EAAE,CAAC;QAClE,OAAO,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,MAAM,GAAG,CAAC,WAAW,EAAE,CAAC;IAC/E,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,KAAK,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;AAC9E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,KAAa;IACjD,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAE9D,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE;QACrC,MAAM,QAAQ,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC;QAClF,OAAO,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;IAC7D,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;AAC7B,CAAC"}

package/dist/editor/reading.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The first step of every function in this tier: text becomes a file, and the
+ * file becomes tokens.
+ *
+ * It is one place rather than four because all four begin identically and
+ * because one of them beginning differently is a bug nobody would look for.
+ *
+ * The bag is created and, for `highlight`, thrown away. That is not waste: the
+ * lexer reports rather than throws, so handing it somewhere to report is how it
+ * is told to carry on, and a highlighter has nothing to say about a character
+ * the language does not have. `diagnose` is what says it.
+ */
+import { DiagnosticBag } from '../core/index.js';
+import type { CheckedScript, Script, SourceFile, Token } from '../core/index.js';
+export interface Read {
+    readonly file: SourceFile;
+    readonly bag: DiagnosticBag;
+    readonly tokens: readonly Token[];
+}
+export interface ReadTree extends Read {
+    readonly script: Script;
+}
+export interface ReadChecked extends ReadTree {
+    readonly checked: CheckedScript;
+}
+/** Text to a file and its tokens. */
+export declare function read(source: string): Read;
+/** The same, with the tree, for the functions that need one. */
+export declare function readTree(source: string): ReadTree;
+/**
+ * The same again, checked, for the two that ask what a name means.
+ *
+ * `complete` and `hover` both need the checker's answers: which names the file
+ * has declared, where each was declared, and what type each one holds. Nothing
+ * here is a lighter version of the checker. It is the checker, run on a file
+ * that is halfway through being typed, which it is built to survive: a name
+ * that does not resolve becomes `unknown` and the lines around it are still
+ * checked, so the names above the cursor are still names.
+ */
+export declare function readChecked(source: string): ReadChecked;
+//# sourceMappingURL=reading.d.ts.map

package/dist/editor/reading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading.d.ts","sourceRoot":"","sources":["../../src/editor/reading.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,aAAa,EAAuC,MAAM,kBAAkB,CAAC;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAejF,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,QAAS,SAAQ,IAAI;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,WAAY,SAAQ,QAAQ;IAC3C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;CACjC;AAED,qCAAqC;AACrC,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAIzC;AAED,gEAAgE;AAChE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAGjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAGvD"}

package/dist/editor/reading.js

@@ -0,0 +1,51 @@
+/**
+ * The first step of every function in this tier: text becomes a file, and the
+ * file becomes tokens.
+ *
+ * It is one place rather than four because all four begin identically and
+ * because one of them beginning differently is a bug nobody would look for.
+ *
+ * The bag is created and, for `highlight`, thrown away. That is not waste: the
+ * lexer reports rather than throws, so handing it somewhere to report is how it
+ * is told to carry on, and a highlighter has nothing to say about a character
+ * the language does not have. `diagnose` is what says it.
+ */
+import { DiagnosticBag, check, lex, parseTokens, sourceFile } from '../core/index.js';
+/**
+ * The name the file is read under, and why none of these functions takes one.
+ *
+ * A `SourceFile` carries a name, and the renderer in the core puts it on the
+ * first line of a rendered diagnostic. Nothing this tier returns carries it: a
+ * diagnostic holds a span, and a highlighted piece holds a span, and neither
+ * holds a file. So a name parameter here would be a parameter a caller can only
+ * get wrong, with nothing anywhere able to notice that they had. A host that
+ * renders a diagnostic with its own file name on it builds the `SourceFile`
+ * itself, from the core, which is where the renderer lives.
+ */
+const UNNAMED = 'script.oscript';
+/** Text to a file and its tokens. */
+export function read(source) {
+    const file = sourceFile(UNNAMED, source);
+    const bag = new DiagnosticBag();
+    return { file, bag, tokens: lex(file, bag) };
+}
+/** The same, with the tree, for the functions that need one. */
+export function readTree(source) {
+    const held = read(source);
+    return { ...held, script: parseTokens(held.file, held.tokens, held.bag) };
+}
+/**
+ * The same again, checked, for the two that ask what a name means.
+ *
+ * `complete` and `hover` both need the checker's answers: which names the file
+ * has declared, where each was declared, and what type each one holds. Nothing
+ * here is a lighter version of the checker. It is the checker, run on a file
+ * that is halfway through being typed, which it is built to survive: a name
+ * that does not resolve becomes `unknown` and the lines around it are still
+ * checked, so the names above the cursor are still names.
+ */
+export function readChecked(source) {
+    const held = readTree(source);
+    return { ...held, checked: check(held.file, held.script, held.bag) };
+}
+//# sourceMappingURL=reading.js.map

package/dist/editor/reading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading.js","sourceRoot":"","sources":["../../src/editor/reading.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGtF;;;;;;;;;;GAUG;AACH,MAAM,OAAO,GAAG,gBAAgB,CAAC;AAgBjC,qCAAqC;AACrC,MAAM,UAAU,IAAI,CAAC,MAAc;IACjC,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,IAAI,aAAa,EAAE,CAAC;IAChC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,QAAQ,CAAC,MAAc;IACrC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,OAAO,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAC5E,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc;IACxC,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AACvE,CAAC"}

package/dist/editor/scan.d.ts

@@ -0,0 +1,26 @@
+import type { SourceFile, Span, Token } from '../core/index.js';
+import type { HighlightKind } from './kinds.js';
+/** One piece of the file, with what it is and the text it covers. */
+export interface Highlight {
+    readonly kind: HighlightKind;
+    readonly span: Span;
+    /**
+     * The source the span covers, carried rather than left to the caller to slice.
+     *
+     * A host that concatenates these gets the file back, so a renderer never
+     * indexes the buffer and never has to agree with this module about what an
+     * offset means. It is also what makes the covering property a one-line test.
+     */
+    readonly text: string;
+}
+/**
+ * Every piece of a file, in order, covering it exactly.
+ *
+ * The token list is walked rather than sorted, and a token that would overlap
+ * the piece before it is skipped rather than believed. Both of those are
+ * defences rather than expectations: the property this returns is what a host
+ * draws with, and it has to hold for a stream from a file somebody is halfway
+ * through typing as firmly as for one from a script that compiles.
+ */
+export declare function scan(file: SourceFile, tokens: readonly Token[]): readonly Highlight[];
+//# sourceMappingURL=scan.d.ts.map

package/dist/editor/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/editor/scan.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAiDD;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,SAAS,EAAE,CA2CrF"}

package/dist/editor/scan.js

@@ -0,0 +1,139 @@
+/**
+ * The covering scan: every character of a file, exactly once, with what it is.
+ *
+ * ## The property that decides the shape
+ *
+ * A host draws highlighting behind or over a text component, and it draws it by
+ * walking a list. Drop one character anywhere on a line and everything after it
+ * on that line is drawn one column to the left, so the caret stops sitting where
+ * the text is. That is not a cosmetic bug: it is the editor feeling broken, and
+ * it is reported as "the cursor is in the wrong place" rather than as a
+ * highlighting fault, which is why it survives.
+ *
+ * So the guarantee here is not "here are the tokens". It is **the spans tile the
+ * source**: they are in order, they do not overlap, none is empty, and their
+ * texts concatenate to the file exactly. A host that renders the spans and
+ * nothing else cannot lose a character, because there is nowhere for one to go.
+ * `tests/editor/highlight.test.ts` holds that over every script in the
+ * repository and over a corpus of malformed ones.
+ *
+ * ## Where the comments come from
+ *
+ * The lexer emits no token for a comment, because the parser has no use for one
+ * (`language.md` 3.10, and it is the rule that lets a commented-out statement
+ * sit at column zero inside a block without closing it). A highlighter does have
+ * a use for one, so they have to be recovered, and this is the one place in the
+ * project that does it. Leaving it to each host is what produced the two
+ * problems this file exists to remove: a platform recovering comments from the
+ * gaps between token spans, and doing it with its own scan for `//`.
+ *
+ * A scan of its own is the wrong answer, because a `//` inside a string literal
+ * is ordinary text (3.2) and finding that out means lexing strings a second
+ * time. This does not scan the file. It walks the tokens the real lexer
+ * produced, and only looks at what is left between them, which by construction
+ * holds no string literal: a `//` in a gap is always a comment, with no second
+ * opinion about the language anywhere in it.
+ *
+ * What else can be in a gap is small and worth naming, because a reader of this
+ * file will want to know whether it can be surprised: blanks, a line continuation
+ * backslash, a region somebody meant as a block comment, and the characters the
+ * lexer refused and reported. All of those are `unknown`, which means "the lexer
+ * took no token from this", and `diagnose` is what says whether any of it is a
+ * mistake.
+ */
+import { endOffset } from '../core/index.js';
+import { kindOf } from './kinds.js';
+const SLASH = 47;
+const LINE_FEED = 10;
+/** Whether a comment opens at `at`: two slashes, which run to the end of the line. */
+function opensComment(text, at) {
+    return text.charCodeAt(at) === SLASH && text.charCodeAt(at + 1) === SLASH;
+}
+function isBlank(code) {
+    // The three the lexer passes over between tokens. A tab is OS1002 in leading
+    // whitespace and is still whitespace to look at, so it is painted as such and
+    // the compiler is left to be the one that objects to it. A lone carriage
+    // return is not one of these: `language.md` 3.1 does not accept it, the lexer
+    // reports it, and painting it as a space would hide the one thing about it
+    // worth knowing.
+    return code === 32 || code === 9 || code === LINE_FEED;
+}
+/** The end of the line `at` sits on, or the end of the file. */
+function endOfLine(text, at) {
+    const found = text.indexOf('\n', at);
+    return found === -1 ? text.length : found;
+}
+/**
+ * A run of one kind inside a gap, from `from` up to but not including its end.
+ *
+ * The three cases are tried in the order they can be told apart: a blank is a
+ * blank, two slashes open a comment to the end of the line, and anything else
+ * runs until one of those two begins.
+ */
+function runIn(text, from, to) {
+    if (isBlank(text.charCodeAt(from))) {
+        let i = from;
+        while (i < to && isBlank(text.charCodeAt(i)))
+            i += 1;
+        return { end: i, kind: 'whitespace' };
+    }
+    if (opensComment(text, from)) {
+        return { end: Math.min(endOfLine(text, from), to), kind: 'comment' };
+    }
+    let i = from;
+    while (i < to && !isBlank(text.charCodeAt(i)) && !opensComment(text, i))
+        i += 1;
+    return { end: i, kind: 'unknown' };
+}
+/**
+ * Every piece of a file, in order, covering it exactly.
+ *
+ * The token list is walked rather than sorted, and a token that would overlap
+ * the piece before it is skipped rather than believed. Both of those are
+ * defences rather than expectations: the property this returns is what a host
+ * draws with, and it has to hold for a stream from a file somebody is halfway
+ * through typing as firmly as for one from a script that compiles.
+ */
+export function scan(file, tokens) {
+    const text = file.text;
+    const out = [];
+    let at = 0;
+    const fill = (to) => {
+        let from = at;
+        while (from < to) {
+            const run = runIn(text, from, to);
+            out.push({
+                kind: run.kind,
+                span: file.spanAt(from, run.end - from),
+                text: text.slice(from, run.end),
+            });
+            from = run.end;
+        }
+    };
+    const read = [];
+    for (const token of tokens) {
+        if (token.span.length === 0) {
+            // A dedent and the end of the file are positions rather than text, and a
+            // newline at the end of a file is one too. Nothing to paint, but the
+            // token still counts as read for the dotted name question next door.
+            read.push(token);
+            continue;
+        }
+        if (token.span.offset < at)
+            continue;
+        if (token.span.offset > at) {
+            fill(token.span.offset);
+            at = token.span.offset;
+        }
+        out.push({
+            kind: kindOf(token, read),
+            span: token.span,
+            text: text.slice(token.span.offset, endOffset(token.span)),
+        });
+        at = endOffset(token.span);
+        read.push(token);
+    }
+    fill(text.length);
+    return out;
+}
+//# sourceMappingURL=scan.js.map

package/dist/editor/scan.js.map

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

package/dist/editor/scope.d.ts

@@ -0,0 +1,19 @@
+import type { Binding, CheckedScript } from '../core/index.js';
+/**
+ * Every name the file itself declares that may be written at an offset.
+ *
+ * A library name is not here: the manifest answers for those, and a binding of
+ * kind `library` is the checker's record of the global scope rather than
+ * something the file declared.
+ */
+export declare function inScopeAt(script: CheckedScript, offset: number): readonly Binding[];
+/**
+ * The binding a name means at an offset, or nothing where the file declares none.
+ *
+ * The declaration itself counts, which the scope rule above deliberately does
+ * not: a name is not in scope inside its own right hand side, and pointing at it
+ * on the line that declares it is still pointing at it. Without this, a hover
+ * over the `x` in `x = ema(close, 9)` would say nothing at all.
+ */
+export declare function bindingNamed(script: CheckedScript, name: string, offset: number): Binding | undefined;
+//# sourceMappingURL=scope.d.ts.map

package/dist/editor/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/editor/scope.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAW,OAAO,EAAE,aAAa,EAAY,MAAM,kBAAkB,CAAC;AAuDlF;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,CASnF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,GAAG,SAAS,CAWrB"}

package/dist/editor/scope.js

@@ -0,0 +1,99 @@
+/**
+ * Which of the file's own names may be written at a position.
+ *
+ * A completion list that offered every name in the file would offer a loop
+ * variable three blocks away and a function parameter from another function,
+ * and a writer accepting one of those gets OS2001 from the compiler a moment
+ * later. So the two rules the language states are applied, and both are asked of
+ * the compiler's own answers rather than worked out again here.
+ *
+ *     declared above     OS2001 is "not defined at this point in the file", so a
+ *                        name is offered from the end of the statement that
+ *                        declares it. Not from the end of the name: `x` is not
+ *                        yet a name inside `x = ema(x, 9)`, and `f` is not one
+ *                        inside `f`'s own body, because recursion is OS2005
+ *     and still inside   a name belongs to the block that declared it
+ *                        (`language.md` 12), so it is offered inside that block
+ *                        and nowhere else
+ *
+ * The bindings are the checker's, not a second walk of the tree: `declaredAt` is
+ * the span the checker points OS2002 and OS8010 at, and the kind, the type and
+ * the persistence are what it worked out. What is derived here is one thing, the
+ * region a binding belongs to, and it is derived from the tree the parser
+ * produced by asking which nodes enclose the declaration.
+ */
+import { containsOffset, endOffset, isStatement, pathAtOffset } from '../core/index.js';
+/**
+ * The node kinds that hold a scope of their own.
+ *
+ * A block is the obvious one. A function declaration is here because its
+ * parameters are declared in its header rather than in its body, and a loop
+ * because its variable is declared in the header too. Anything else a name is
+ * declared inside belongs to whichever of these encloses it, and a file level
+ * name belongs to the file.
+ */
+const SCOPES = new Set([
+    'block',
+    'functionDeclaration',
+    'forRangeStatement',
+    'forInStatement',
+]);
+const HEADERS = new Set(['parameter', 'loop']);
+function regionOf(script, binding) {
+    const path = pathAtOffset(script.script, binding.declaredAt.offset);
+    let node;
+    let statement;
+    for (let i = path.length - 1; i >= 0; i -= 1) {
+        const held = path[i];
+        if (held === undefined)
+            continue;
+        if (statement === undefined && isStatement(held))
+            statement = held;
+        if (SCOPES.has(held.kind)) {
+            node = held;
+            break;
+        }
+    }
+    const from = HEADERS.has(binding.kind)
+        ? endOffset(binding.declaredAt)
+        : endOffset(statement?.span ?? binding.declaredAt);
+    return { node, from };
+}
+/**
+ * Every name the file itself declares that may be written at an offset.
+ *
+ * A library name is not here: the manifest answers for those, and a binding of
+ * kind `library` is the checker's record of the global scope rather than
+ * something the file declared.
+ */
+export function inScopeAt(script, offset) {
+    return script.bindings.filter((binding) => {
+        if (binding.kind === 'library')
+            return false;
+        const region = regionOf(script, binding);
+        if (region.from > offset)
+            return false;
+        // No enclosing scope node means the file, and the file holds every offset,
+        // including the one past its last character where somebody is typing.
+        return region.node === undefined || containsOffset(region.node.span, offset);
+    });
+}
+/**
+ * The binding a name means at an offset, or nothing where the file declares none.
+ *
+ * The declaration itself counts, which the scope rule above deliberately does
+ * not: a name is not in scope inside its own right hand side, and pointing at it
+ * on the line that declares it is still pointing at it. Without this, a hover
+ * over the `x` in `x = ema(close, 9)` would say nothing at all.
+ */
+export function bindingNamed(script, name, offset) {
+    const declaring = script.bindings.find((binding) => binding.name === name && containsOffset(binding.declaredAt, offset));
+    if (declaring !== undefined)
+        return declaring;
+    const held = inScopeAt(script, offset).filter((binding) => binding.name === name);
+    // The innermost declaration wins, which is the one declared last among those
+    // still in scope: a block level name shadows a file level one of the same
+    // spelling for as long as its block lasts.
+    return held[held.length - 1];
+}
+//# sourceMappingURL=scope.js.map

package/dist/editor/scope.js.map

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

package/dist/editor/signature.d.ts

@@ -0,0 +1,38 @@
+import type { Span } from '../core/index.js';
+import type { Parameter } from './manifest.js';
+export interface SignatureHelp {
+    /** The callee as written: `ema`, `draw.box`, or a name the file declared. */
+    readonly name: string;
+    /** Whether the library holds it or the file declares it. */
+    readonly of: 'library' | 'declared';
+    /** The signature written out, the way the specification's tables write one. */
+    readonly signature: string;
+    readonly parameters: readonly Parameter[];
+    /**
+     * Which parameter the cursor is in, or -1 where it is in none.
+     *
+     * A label decides it where one is written, because `plot(close, color = ` is
+     * in `color` whatever position it sits in; otherwise the count of commas
+     * decides. It is -1 past the last parameter, which is a call with more
+     * arguments than the signature takes and is OS3001 the moment it is compiled.
+     */
+    readonly active: number;
+    /** The line the specification gives the call, where it gives one. */
+    readonly summary: string | undefined;
+    /** Named in the library and not implemented in this version: OS2020. */
+    readonly planned: boolean;
+    readonly refusal: string | undefined;
+    /** The callee's own name, for a host anchoring a tooltip to the call. */
+    readonly span: Span;
+}
+/**
+ * The call the cursor is inside, or nothing where it is inside none.
+ *
+ * Nothing is the answer for a cursor outside every bracket, and for one inside a
+ * bracket whose callee the language does not have: a name that resolves to
+ * neither the library nor the file is OS2001, and `diagnose` is what says so.
+ * A tooltip that invented a signature for it would be a second opinion about
+ * what the file declares.
+ */
+export declare function signature(source: string, offset: number): SignatureHelp | undefined;
+//# sourceMappingURL=signature.d.ts.map

package/dist/editor/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/editor/signature.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAiB,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK/C,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,UAAU,CAAC;IACpC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAyDD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAsBnF"}