rooklang 0.0.0-stage → 0.3.0

package/dist/lexer/style.js

@@ -0,0 +1,97 @@
+import { MarkupLexer } from "./markup.js";
+/**
+ * The start of a declaration: a property name, a colon and then a space or a value, `color: ` or
+ * `color:{`. With a name right after the colon it is a selector, `a:hover`, so `{` there opens a
+ * nested rule.
+ */
+const DECLARATION = /^\s*-{0,2}[a-zA-Z_][\w-]*\s*:(?:\s|[^\w\-:\\]|$)/;
+export class StyleLexer extends MarkupLexer {
+    /**
+     * `style {` at the start of a statement starts CSS: the identifier `style` has just been read at
+     * `start`. Elsewhere `style` is an ordinary name.
+     */
+    startStyle(start) {
+        const before = this.tokens.at(-2);
+        const startsStatement = before === undefined || before.kind === ';' || before.kind === '{' || before.kind === '}';
+        const brace = /^[ \t]*\{/.exec(this.text.slice(this.pos));
+        if (!startsStatement || !brace)
+            return;
+        const open = this.pos + brace[0].length - 1;
+        this.push('{', open, open + 1);
+        this.modes.push({ kind: 'css', start, depth: 0, item: '' });
+    }
+    /** CSS text up to a value from code or to the `}` that closes the block. */
+    scanCss(mode) {
+        const t = this.text;
+        const start = this.pos;
+        let i = start;
+        const flush = (end) => {
+            if (end > start) {
+                const text = t.slice(start, end);
+                this.tokens.push({ kind: 'CssText', value: text, text, start, end });
+            }
+        };
+        while (i < t.length) {
+            const c = t[i];
+            if (c === '/' && t[i + 1] === '*') {
+                const end = t.indexOf('*/', i + 2);
+                if (end === -1) {
+                    this.error('unterminated comment in CSS', i, i + 2);
+                    i = t.length;
+                }
+                else {
+                    i = end + 2;
+                }
+            }
+            else if (c === '"' || c === "'") {
+                const end = this.cssStringEnd(i);
+                mode.item += t.slice(i, end);
+                i = end;
+            }
+            else if (c === '{' && mode.depth > 0 && DECLARATION.test(mode.item)) {
+                // A value from code: the item gets a stand-in, so that the next `{` is a value too.
+                flush(i);
+                this.push('{', i, i + 1);
+                mode.item += '0';
+                this.modes.push({ kind: 'expression', braces: 0 });
+                return;
+            }
+            else if (c === '{') {
+                mode.depth++;
+                mode.item = '';
+                i++;
+            }
+            else if (c === '}' && mode.depth === 0) {
+                flush(i);
+                this.push('}', i, i + 1);
+                this.modes.pop();
+                return;
+            }
+            else if (c === '}' || c === ';') {
+                if (c === '}')
+                    mode.depth--;
+                mode.item = '';
+                i++;
+            }
+            else {
+                mode.item += c;
+                i++;
+            }
+        }
+        flush(i);
+        this.pos = i;
+    }
+    /** The end of a CSS string that starts at `start`, after its closing quote. */
+    cssStringEnd(start) {
+        const t = this.text;
+        const quote = t[start];
+        let i = start + 1;
+        while (i < t.length && t[i] !== quote && t[i] !== '\n')
+            i += t[i] === '\\' ? 2 : 1;
+        if (t[i] !== quote) {
+            this.error('unterminated string in CSS', start, i);
+            return i;
+        }
+        return i + 1;
+    }
+}

package/dist/lexer/tables.d.ts

@@ -0,0 +1,53 @@
+import type { TokenKind } from './token.ts';
+/**
+ * A line break after one of these tokens ends the statement, so the lexer inserts a semicolon
+ * there (the same rule as in Go).
+ */
+export declare const ENDS_STATEMENT: ReadonlySet<TokenKind>;
+/**
+ * Tokens that end a value: after them `<` means "less than", elsewhere it starts markup. The
+ * language has no `<...>` generics or casts, so this is never ambiguous.
+ */
+export declare const ENDS_VALUE: ReadonlySet<TokenKind>;
+/** Tag and attribute names: `div`, `my-widget`, `aria-label`, `bind:value`. */
+export declare const JSX_NAME: RegExp;
+export declare const ENTITIES: Readonly<Record<string, string>>;
+/** Decodes HTML entities in markup text: `&amp;`, `&#169;`, `&#xA9;`. */
+export declare function decodeEntities(text: string): string;
+export declare const IDENTIFIER: RegExp;
+export declare const SIMPLE_ESCAPES: Readonly<Record<string, string>>;
+export type CharTest = (c: string | undefined) => boolean;
+export declare const isDigit: CharTest;
+export declare const isHexDigit: CharTest;
+export declare const isOctalDigit: CharTest;
+export declare const isBinaryDigit: CharTest;
+/**
+ * What the lexer is inside of, innermost last. `start` is where the template or element begins,
+ * for error messages; `braces` counts unclosed `{` inside a substitution or expression.
+ */
+export type Mode = {
+    kind: 'template';
+    start: number;
+    braces: number;
+} | {
+    kind: 'expression';
+    braces: number;
+} | {
+    kind: 'tag';
+    start: number;
+} | {
+    kind: 'content';
+    start: number;
+} | {
+    kind: 'closingTag';
+    start: number;
+} | {
+    kind: 'css';
+    start: number;
+    depth: number;
+    item: string;
+};
+export type MarkupMode = Extract<Mode, {
+    kind: 'tag' | 'content' | 'closingTag';
+}>;
+export declare function isMarkup(mode: Mode | undefined): mode is MarkupMode;

package/dist/lexer/tables.js

@@ -0,0 +1,101 @@
+// Tables of the lexer: which tokens end a statement or a value, entities, escapes, modes.
+/**
+ * A line break after one of these tokens ends the statement, so the lexer inserts a semicolon
+ * there (the same rule as in Go).
+ */
+export const ENDS_STATEMENT = new Set([
+    'Identifier',
+    'Number',
+    'BigInt',
+    'String',
+    'Template',
+    'TemplateTail',
+    'true',
+    'false',
+    'null',
+    'this',
+    'return',
+    'break',
+    'continue',
+    '++',
+    '--',
+    ')',
+    ']',
+    '}',
+    'JsxTagEnd',
+    'JsxSelfClose',
+]);
+/**
+ * Tokens that end a value: after them `<` means "less than", elsewhere it starts markup. The
+ * language has no `<...>` generics or casts, so this is never ambiguous.
+ */
+export const ENDS_VALUE = new Set([
+    'Identifier',
+    'Number',
+    'BigInt',
+    'String',
+    'Template',
+    'TemplateTail',
+    'true',
+    'false',
+    'null',
+    'this',
+    'super',
+    '++',
+    '--',
+    ')',
+    ']',
+    '}',
+    'JsxTagEnd',
+    'JsxSelfClose',
+]);
+/** Tag and attribute names: `div`, `my-widget`, `aria-label`, `bind:value`. */
+export const JSX_NAME = /[\p{ID_Start}$_][\p{ID_Continue}$\-:.]*/uy;
+export const ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: '\u00a0',
+    copy: '©',
+    times: '×',
+    middot: '·',
+    hellip: '…',
+    mdash: '—',
+    ndash: '–',
+    laquo: '«',
+    raquo: '»',
+};
+/** Decodes HTML entities in markup text: `&amp;`, `&#169;`, `&#xA9;`. */
+export function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (entity, name) => {
+        if (name.startsWith('#')) {
+            const code = name[1] === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+            return code <= 0x10ffff ? String.fromCodePoint(code) : entity;
+        }
+        return Object.hasOwn(ENTITIES, name) ? ENTITIES[name] : entity;
+    });
+}
+export const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*/uy;
+export const SIMPLE_ESCAPES = {
+    n: '\n',
+    t: '\t',
+    r: '\r',
+    b: '\b',
+    f: '\f',
+    v: '\v',
+    '0': '\0',
+    '\\': '\\',
+    "'": "'",
+    '"': '"',
+    '`': '`',
+    $: '$',
+};
+export const isDigit = (c) => c !== undefined && c >= '0' && c <= '9';
+export const isHexDigit = (c) => c !== undefined && /^[0-9a-fA-F]$/.test(c);
+export const isOctalDigit = (c) => c !== undefined && c >= '0' && c <= '7';
+export const isBinaryDigit = (c) => c === '0' || c === '1';
+export function isMarkup(mode) {
+    return mode?.kind === 'tag' || mode?.kind === 'content' || mode?.kind === 'closingTag';
+}

package/dist/lexer/token.d.ts

@@ -0,0 +1,42 @@
+export declare const KEYWORDS: readonly ["func", "comp", "go", "chan", "return", "let", "const", "type", "interface", "class", "extends", "new", "this", "super", "if", "else", "for", "in", "break", "continue", "switch", "case", "default", "defer", "try", "catch", "finally", "throw", "import", "export", "null", "true", "false", "typeof", "instanceof", "async", "await", "map"];
+export declare const PUNCTUATORS: readonly ["{", "}", "(", ")", "[", "]", ";", ",", ":", ".", "...", "?", "?.", "??", "=>", "=", "+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "&&=", "||=", "??=", "==", "!=", "<", "<-", ">", "<=", ">=", "+", "-", "*", "/", "%", "**", "++", "--", "&", "|", "^", "~", "<<", ">>", ">>>", "&&", "||", "!", "@"];
+export type Keyword = (typeof KEYWORDS)[number];
+export type Punctuator = (typeof PUNCTUATORS)[number];
+/**
+ * Token kinds whose `value` holds string contents. Template literals are split around
+ * substitutions: `a${x}b${y}c` becomes TemplateHead("a") x TemplateMiddle("b") y TemplateTail("c"),
+ * and a template without substitutions is a single Template token. In markup, JsxText is the text
+ * between tags and JsxString an attribute value in quotes; both have HTML entities decoded. CssText is
+ * the raw text of a `style { ... }` block between the values from code.
+ */
+export type StringKind = 'String' | 'Template' | 'TemplateHead' | 'TemplateMiddle' | 'TemplateTail' | 'JsxText' | 'JsxString' | 'CssText';
+/**
+ * Tokens of markup such as `<a href="/">text</a>`: JsxTagOpen `<`, JsxCloseTagOpen `</`, JsxName
+ * (tag and attribute names, which may contain `-` and `:`), JsxTagEnd `>` and JsxSelfClose `/>`.
+ * Expressions inside markup use the ordinary `{`, `}` and `=` tokens.
+ */
+export type JsxKind = 'JsxTagOpen' | 'JsxCloseTagOpen' | 'JsxName' | 'JsxTagEnd' | 'JsxSelfClose';
+/** Keywords and punctuators use their own text as the kind, e.g. `func` or `+=`. */
+export type TokenKind = 'Identifier' | 'Number' | 'BigInt' | StringKind | JsxKind | 'EOF' | Keyword | Punctuator;
+interface TokenBase {
+    /** Source text. Empty for automatically inserted semicolons and EOF. */
+    text: string;
+    start: number;
+    end: number;
+}
+export interface NumberToken extends TokenBase {
+    kind: 'Number';
+    value: number;
+}
+export interface StringToken extends TokenBase {
+    kind: StringKind;
+    /** Contents with escapes resolved, without quotes and `${` / `}` delimiters. */
+    value: string;
+}
+export interface SimpleToken extends TokenBase {
+    kind: Exclude<TokenKind, 'Number' | StringKind>;
+}
+export type Token = NumberToken | StringToken | SimpleToken;
+export declare function isKeyword(word: string): word is Keyword;
+export declare function isPunctuator(text: string): text is Punctuator;
+export {};

package/dist/lexer/token.js

@@ -0,0 +1,108 @@
+export const KEYWORDS = [
+    'func',
+    'comp',
+    'go',
+    'chan',
+    'return',
+    'let',
+    'const',
+    'type',
+    'interface',
+    'class',
+    'extends',
+    'new',
+    'this',
+    'super',
+    'if',
+    'else',
+    'for',
+    'in',
+    'break',
+    'continue',
+    'switch',
+    'case',
+    'default',
+    'defer',
+    'try',
+    'catch',
+    'finally',
+    'throw',
+    'import',
+    'export',
+    'null',
+    'true',
+    'false',
+    'typeof',
+    'instanceof',
+    'async',
+    'await',
+    // Reserved for future use.
+    'map',
+];
+export const PUNCTUATORS = [
+    '{',
+    '}',
+    '(',
+    ')',
+    '[',
+    ']',
+    ';',
+    ',',
+    ':',
+    '.',
+    '...',
+    '?',
+    '?.',
+    '??',
+    '=>',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '**=',
+    '&=',
+    '|=',
+    '^=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '&&=',
+    '||=',
+    '??=',
+    '==',
+    '!=',
+    '<',
+    '<-',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '**',
+    '++',
+    '--',
+    '&',
+    '|',
+    '^',
+    '~',
+    '<<',
+    '>>',
+    '>>>',
+    '&&',
+    '||',
+    '!',
+    '@',
+];
+const KEYWORD_SET = new Set(KEYWORDS);
+const PUNCTUATOR_SET = new Set(PUNCTUATORS);
+export function isKeyword(word) {
+    return KEYWORD_SET.has(word);
+}
+export function isPunctuator(text) {
+    return PUNCTUATOR_SET.has(text);
+}

package/dist/loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loader.js

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { registerHooks } from 'node:module';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isMainThread } from 'node:worker_threads';
+import { displayPath } from "./build.js";
+import { compileFile } from "./compile-file.js";
+// `rook run` imports this module first (`node --import`): Node then imports `.rk` files,
+// compiled when they load, and `app.rk?goroutines` is the worker module of `go` in app.rk.
+// The worker threads of `go` import it too, since they get the `--import` of the process. The main
+// thread compiles a module before any worker needs it, so it leaves the code of each module and
+// of its worker module in ROOK_RUN_CACHE, a directory of the run, and the workers take it from
+// there: compiling again, with the types, would take each of them as long. ROOK_NO_CHECK turns
+// type checking off, and ROOK_MARKUP, 1 or 0, markup and components on or off for every file.
+const typeCheck = process.env['ROOK_NO_CHECK'] === undefined;
+const markupSetting = process.env['ROOK_MARKUP'];
+const markup = markupSetting === undefined ? undefined : markupSetting === '1';
+const cache = process.env['ROOK_RUN_CACHE'];
+/** The file of the cache for the code of a URL, query included. */
+function cached(url) {
+    return cache ? join(cache, `${createHash('sha1').update(url).digest('hex')}.js`) : null;
+}
+registerHooks({
+    load(url, context, nextLoad) {
+        const { protocol, pathname, search } = new URL(url);
+        if (protocol !== 'file:' || !pathname.endsWith('.rk'))
+            return nextLoad(url, context);
+        const file = cached(url);
+        if (!isMainThread && file && existsSync(file)) {
+            return { format: 'module', source: readFileSync(file, 'utf8'), shortCircuit: true };
+        }
+        const moduleUrl = new URL(pathname, url).href;
+        const path = displayPath(fileURLToPath(moduleUrl));
+        const result = compileFile(path, {
+            rewriteImports: false,
+            typeCheck,
+            markup,
+            quiet: !isMainThread,
+        });
+        if (isMainThread && cache) {
+            writeFileSync(cached(moduleUrl), result.code);
+            if (result.worker !== undefined) {
+                writeFileSync(cached(`${moduleUrl}?goroutines`), result.worker);
+            }
+        }
+        const source = search === '?goroutines' ? (result.worker ?? '') : result.code;
+        return { format: 'module', source, shortCircuit: true };
+    },
+});

package/dist/methods.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from './checker/types.ts';
+/** Array methods that change the array. */
+export declare const ARRAY_MUTATORS: ReadonlySet<string>;
+/** Whether calling `method` may change a value of this type. */
+export declare function mayChange(type: Type | undefined, method: string): boolean;

package/dist/methods.js

@@ -0,0 +1,81 @@
+// Which methods change the value they are called on and which only read it. The generator updates
+// markup after changes; the checker forbids changes of values that are read-only.
+/** Array methods that change the array. */
+export const ARRAY_MUTATORS = new Set([
+    'copyWithin',
+    'fill',
+    'pop',
+    'push',
+    'reverse',
+    'shift',
+    'sort',
+    'splice',
+    'unshift',
+]);
+/** Methods known to only read, for values that are not arrays or whose type is not known. */
+const READ_METHODS = new Set([
+    'at',
+    'charAt',
+    'concat',
+    'endsWith',
+    'entries',
+    'every',
+    'filter',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'flat',
+    'flatMap',
+    'forEach',
+    'getTime',
+    'includes',
+    'indexOf',
+    'join',
+    'keys',
+    'lastIndexOf',
+    'map',
+    'padEnd',
+    'padStart',
+    'reduce',
+    'reduceRight',
+    'repeat',
+    'replace',
+    'replaceAll',
+    'slice',
+    'some',
+    'split',
+    'startsWith',
+    'substring',
+    'toFixed',
+    'toISOString',
+    'toLocaleDateString',
+    'toLocaleString',
+    'toLocaleTimeString',
+    'toLowerCase',
+    'toReversed',
+    'toSorted',
+    'toSpliced',
+    'toString',
+    'toUpperCase',
+    'trim',
+    'trimEnd',
+    'trimStart',
+    'valueOf',
+    'values',
+    'with',
+]);
+/** Whether calling `method` may change a value of this type. */
+export function mayChange(type, method) {
+    const known = type?.kind === 'nullable' ? type.type : type;
+    switch (known?.kind) {
+        case 'string':
+        case 'number':
+        case 'bool':
+            return false;
+        case 'array':
+            return ARRAY_MUTATORS.has(method);
+        default:
+            return ARRAY_MUTATORS.has(method) || !READ_METHODS.has(method);
+    }
+}

package/dist/modules.d.ts

@@ -0,0 +1,3 @@
+import { type ImportResult } from './checker/checker.ts';
+/** Finds the types exported by a `.rk` module imported from the file `fromFile`. */
+export declare function loadModuleExports(fromFile: string, specifier: string, markup?: boolean): ImportResult;

package/dist/modules.js

@@ -0,0 +1,49 @@
+import { readFileSync, statSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { check } from "./checker/checker.js";
+import { markupFor } from "./config.js";
+import { parse } from "./parser/parser.js";
+import { importDeclarations, libraryFor } from "./typescript/importer.js";
+/** Exports of checked modules, by path; reused while the file does not change. */
+const cache = new Map();
+const loading = new Set();
+/** Finds the types exported by a `.rk` module imported from the file `fromFile`. */
+export function loadModuleExports(fromFile, specifier, markup) {
+    if (!specifier.startsWith('./') && !specifier.startsWith('../'))
+        return undefined;
+    const path = resolve(dirname(fromFile), specifier);
+    let version;
+    try {
+        const stats = statSync(path);
+        version = `${stats.mtimeMs}:${stats.size}`;
+    }
+    catch {
+        return { error: `cannot find module "${specifier}"` };
+    }
+    const cached = cache.get(path);
+    if (cached?.version === version)
+        return { exports: cached.exports };
+    // An import cycle: the module is being checked further up the chain, so it is untyped here.
+    if (loading.has(path))
+        return undefined;
+    loading.add(path);
+    try {
+        // The markup of the CLI or the Vite plugin, else that of the package of the module.
+        const { program, diagnostics } = parse(readFileSync(path, 'utf8'), {
+            markup: markup ?? markupFor(path),
+        });
+        // Syntax errors in the imported module are reported when that module itself is compiled.
+        if (diagnostics.length > 0)
+            return undefined;
+        const { exports } = check(program, {
+            importModule: (next) => loadModuleExports(path, next, markup),
+            importDeclarations: (next) => importDeclarations(path, next),
+            library: libraryFor(path),
+        });
+        cache.set(path, { version, exports });
+        return { exports };
+    }
+    finally {
+        loading.delete(path);
+    }
+}

package/dist/names.d.ts

@@ -0,0 +1,23 @@
+import type * as ast from './ast.ts';
+/** Names assigned anywhere inside `node`: `x = ...`, `x += ...`, `x++`. */
+export declare function assignedNames(node: ast.Node, names?: Set<string>): Set<string>;
+/** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
+export declare function mentionsName(node: ast.Node, names: ReadonlySet<string>): boolean;
+/** Every name declared inside `node`: parameters and all local declarations, nested ones too. */
+export declare function declaredNames(node: ast.Node): Set<string>;
+/** Names a component or a decorator uses as values but does not declare: those come from the module. */
+export declare function freeNames(component: {
+    params: readonly ast.Parameter[];
+    body: ast.BlockStatement;
+}): Set<string>;
+/** Names declared directly in a list of statements: they hide outer names in the whole block. */
+export declare function declaredIn(statements: readonly ast.Statement[]): string[];
+/** Names declared at the top level of a module, imports included: what its code can use. */
+export declare function topLevelNames(program: ast.Program): Set<string>;
+/**
+ * Names used as values, as opposed to declared names, property names and types. A capitalized tag
+ * is a value unless `isComponent` says it names a component: `<Page />` with a variable `Page`.
+ */
+export declare function collectValueNames(node: ast.Node, names: Set<string>, isComponent?: (name: string) => boolean): void;
+/** The components that the code in `node` uses as values: `content: Intro`. */
+export declare function componentValues(node: ast.Node, isComponent: (name: string) => boolean): string[];