rooklang 0.0.0-stage → 0.3.0

package/dist/compile.js

@@ -0,0 +1,187 @@
+import { check, } from "./checker/checker.js";
+import { property, STRING } from "./checker/types.js";
+import { generateJs } from "./codegen/js.js";
+import { printDeclarations } from "./declarations.js";
+import { goroutines, goTarget, workerProgram } from "./goroutines.js";
+import { parse } from "./parser/parser.js";
+import { isStyleModule, styleModule, unusedClasses } from "./style-modules.js";
+/**
+ * Where the worker module of a module is: a `.worker.js` next to its `.js`, or, where `.rk`
+ * files are imported as they are (`rook run`), the module itself with `?goroutines`. Vite drops
+ * the query of a worker's URL, so its plugin gives another path (vite.ts).
+ */
+export function workerUrl(file, rewriteImports) {
+    const base = file.replace(/^.*[\\/]/, '').replace(/\.rk$/, '');
+    return rewriteImports ? `./${base}.worker.js` : `./${base}.rk?goroutines`;
+}
+export function compileModule(source, options = {}) {
+    const { program, diagnostics } = parse(source, { markup: options.markup ?? true });
+    if (diagnostics.length > 0)
+        return { code: '', diagnostics, warnings: [], dependencies: [] };
+    const dependencies = localImports(program);
+    const { styleModules, problems, checkOptions } = prepareCheck(program, options);
+    if (problems.length > 0)
+        return { code: '', diagnostics: problems, warnings: [], dependencies };
+    let types;
+    let declarations;
+    let warnings = [];
+    if (options.typeCheck ?? true) {
+        const checked = check(program, checkOptions);
+        warnings = [...checked.warnings, ...unusedStyleClasses(program, styleModules)].sort((a, b) => a.start - b.start);
+        if (checked.diagnostics.length > 0) {
+            return { code: '', diagnostics: checked.diagnostics, warnings, dependencies };
+        }
+        types = checked.types;
+        if (options.declarations)
+            declarations = printDeclarations(program, checked);
+    }
+    const rewriteImports = options.rewriteImports ?? true;
+    const jsOptions = {
+        source,
+        rewriteImports,
+        types,
+        styleModules,
+        ...importedCode(program, options.importModule),
+    };
+    const code = generateJs(program, {
+        ...jsOptions,
+        goroutines: { workerUrl: options.workerUrl ?? workerUrl('main.rk', rewriteImports) },
+    });
+    const targets = [
+        ...new Set(goroutines(program).flatMap((node) => goTarget(program, node) ?? [])),
+    ];
+    const worker = targets.length > 0
+        ? generateJs(workerProgram(program, targets), { ...jsOptions, goroutines: { targets } })
+        : undefined;
+    return {
+        code,
+        diagnostics: [],
+        warnings,
+        dependencies,
+        ...(declarations ? { declarations } : {}),
+        ...(worker === undefined ? {} : { worker }),
+    };
+}
+/**
+ * The options of the checker for a program: its imports, with the CSS modules it imports, which
+ * are read and parsed here (or what is wrong with them), and the library.
+ */
+export function prepareCheck(program, options) {
+    const { styleModules, problems } = readStyleModules(program, options.readStyleModule);
+    const { importModule, importDeclarations, library } = options;
+    // A CSS module has a default export: an object with a string for each of its classes.
+    const importStyles = (specifier) => {
+        const module = styleModules.get(specifier);
+        return module
+            ? { exports: styleModuleExports(specifier, module) }
+            : importDeclarations?.(specifier);
+    };
+    return {
+        styleModules,
+        problems,
+        checkOptions: {
+            ...(importModule ? { importModule } : {}),
+            importDeclarations: importStyles,
+            ...(library ? { library } : {}),
+        },
+    };
+}
+/**
+ * What the module imports from other `.rk` modules for the generator: decorators, whose code is
+ * inlined, and components, which are called or inlined.
+ */
+function importedCode(program, importModule) {
+    const found = new Map();
+    const components = new Map();
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration' || !statement.source.value.endsWith('.rk')) {
+            continue;
+        }
+        const result = importModule?.(statement.source.value);
+        const exports = result && 'exports' in result ? result.exports : undefined;
+        const decorators = exports?.decorators;
+        for (const specifier of statement.namedImports) {
+            const component = exports?.components?.get(specifier.imported.name);
+            if (component) {
+                components.set(specifier.local.name, {
+                    node: component.node,
+                    inline: component.inline,
+                    types: component.expressionTypes,
+                    root: component.root ?? 'is not known in advance',
+                });
+            }
+            const info = decorators?.get(specifier.imported.name);
+            if (!info)
+                continue;
+            found.set(specifier.local.name, {
+                node: info.node,
+                moduleNames: info.moduleNames,
+                types: info.expressionTypes,
+                inline: info.inline,
+            });
+        }
+    }
+    return { decorators: found, components };
+}
+/** The CSS modules that the program imports, read and parsed, or what is wrong with them. */
+function readStyleModules(program, read) {
+    const styleModules = new Map();
+    const problems = [];
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration' || !isStyleModule(statement.source.value))
+            continue;
+        const { source } = statement;
+        const text = read?.(source.value) ?? null;
+        const problem = (message) => problems.push({ message, start: source.start, end: source.end });
+        if (text === null) {
+            problem(read
+                ? `cannot read the CSS module "${source.value}"`
+                : 'CSS modules need files: build the program with rook build or Vite');
+            continue;
+        }
+        const module = styleModule(text);
+        for (const message of module.problems)
+            problem(`${source.value}: ${message}`);
+        styleModules.set(source.value, module);
+    }
+    return { styleModules, problems };
+}
+function styleModuleExports(specifier, module) {
+    const members = new Map([...module.classes.keys()].map((name) => [name, property(STRING)]));
+    const name = specifier.split('/').at(-1);
+    return {
+        values: new Map([['default', { kind: 'object', name, members, call: null }]]),
+        types: new Map(),
+    };
+}
+function unusedStyleClasses(program, styleModules) {
+    const found = [];
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration' || !statement.defaultImport)
+            continue;
+        const module = styleModules.get(statement.source.value);
+        if (!module)
+            continue;
+        for (const name of unusedClasses(program, statement.defaultImport.name, module)) {
+            found.push({
+                message: `class "${name}" of ${statement.source.value} is never used`,
+                start: statement.source.start,
+                end: statement.source.end,
+            });
+        }
+    }
+    return found;
+}
+/** The relative imports of `.rk` modules and CSS modules: what the module depends on. */
+function localImports(program) {
+    const specifiers = new Set();
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration')
+            continue;
+        const path = statement.source.value;
+        if (/^\.{1,2}\//.test(path) && (path.endsWith('.rk') || isStyleModule(path))) {
+            specifiers.add(path);
+        }
+    }
+    return [...specifiers];
+}

package/dist/completion.d.ts

@@ -0,0 +1,10 @@
+import { type Completion } from './checker/checker.ts';
+import { type CoreCompileOptions } from './compile.ts';
+export type { Completion, CompletionContext } from './checker/checker.ts';
+export interface CompletionList {
+    /** Offsets of what the chosen item replaces: the part of the name before the cursor. */
+    start: number;
+    end: number;
+    items: Completion[];
+}
+export declare function completeModule(source: string, offset: number, options?: CoreCompileOptions): CompletionList;

package/dist/completion.js

@@ -0,0 +1,134 @@
+import { check } from "./checker/checker.js";
+import { prepareCheck } from "./compile.js";
+import { tokenize } from "./lexer/lexer.js";
+import { KEYWORDS } from "./lexer/token.js";
+import { parse } from "./parser/parser.js";
+import { RESERVED } from "./parser/syntax.js";
+import { forEachChild } from "./walk.js";
+const CURSOR = '$$cursor';
+const STRINGS = new Set([
+    'String',
+    'Template',
+    'TemplateHead',
+    'TemplateMiddle',
+    'TemplateTail',
+    'JsxText',
+    'JsxString',
+    'CssText',
+]);
+const VALUE_KEYWORDS = KEYWORDS.filter((keyword) => !RESERVED.has(keyword));
+const TYPE_KEYWORDS = ['func', 'comp', 'chan'];
+/** Keywords only at the start of a statement at the top level of a component or a decorator. */
+const COMPONENT_KEYWORDS = ['state', 'derived', 'ref', 'style', 'effect', 'mount'];
+export function completeModule(source, offset, options = {}) {
+    const { tokens } = tokenize(source);
+    const empty = { start: offset, end: offset, items: [] };
+    const token = tokens.find((each) => each.start < offset && offset <= each.end);
+    if (token && STRINGS.has(token.kind) && offset < token.end)
+        return empty;
+    if (token?.kind === 'Number' || (!token && inComment(source, tokens, offset)))
+        return empty;
+    // The name being typed, `ti|tle`, is replaced as a whole.
+    const word = token && /^[\p{ID_Start}$_]/u.test(token.text) ? token : null;
+    const start = word?.start ?? offset;
+    const end = word?.end ?? offset;
+    const before = source.slice(0, start) + CURSOR;
+    const after = source.slice(end);
+    const nextLines = after.replace(/^.*/, '');
+    const line = source.slice(source.lastIndexOf('\n', start - 1) + 1, start);
+    const open = unclosed(source.slice(0, start));
+    const attempts = [
+        ...new Set([
+            before + after,
+            before + unclosed(line) + nextLines,
+            before + open + nextLines,
+            `${before + open} {}${nextLines}`,
+        ]),
+    ];
+    // `<Ca|` without the rest of the element yet.
+    if (word?.kind === 'JsxName' ||
+        tokens.some((each) => each.kind === 'JsxTagOpen' && each.end === start)) {
+        attempts.splice(1, 0, `${before} />${after}`);
+    }
+    for (const text of attempts) {
+        const { program } = parse(text, { markup: options.markup ?? true });
+        const result = completeIn(program, options);
+        if (result) {
+            return { start, end: offset, items: withKeywords(result, statementKeywords(program)) };
+        }
+        // The cursor is where a name is declared, `let ti|`: nothing to suggest.
+        if (pathTo(program, CURSOR).length > 0)
+            return empty;
+    }
+    return { start, end: offset, items: VALUE_KEYWORDS.map(keyword) };
+}
+function completeIn(program, options) {
+    const { checkOptions } = prepareCheck(program, options);
+    try {
+        return check(program, { ...checkOptions, completion: CURSOR }).completion ?? null;
+    }
+    catch {
+        // The tree that the parser recovered from errors may surprise the checker.
+        return null;
+    }
+}
+function withKeywords({ context, items }, statement) {
+    if (context === 'value')
+        return [...items, ...[...statement, ...VALUE_KEYWORDS].map(keyword)];
+    if (context === 'type')
+        return [...items, ...TYPE_KEYWORDS.map(keyword)];
+    return items;
+}
+function keyword(name) {
+    return { name, kind: 'keyword' };
+}
+/** Whether the offset is in a comment: comments are the only text between tokens. */
+function inComment(source, tokens, offset) {
+    const previous = tokens.findLast((each) => each.end <= offset && each.text !== '');
+    const gap = source.slice(previous?.end ?? 0, offset);
+    const block = gap.lastIndexOf('/*');
+    return gap.slice(gap.lastIndexOf('\n') + 1).includes('//') || block > gap.lastIndexOf('*/');
+}
+/**
+ * Words that are keywords only at the start of a statement (see src/parser/statements.ts), when the
+ * cursor starts one: `select` anywhere, `dec` at the top level of the module and `state` and the
+ * like at the top level of a component or a decorator.
+ */
+function statementKeywords(program) {
+    const path = pathTo(program, CURSOR);
+    const [statement, block, owner] = [path.at(-2), path.at(-3), path.at(-4)];
+    if (statement?.kind !== 'ExpressionStatement')
+        return [];
+    if (block?.kind === 'Program')
+        return ['select', 'dec'];
+    const component = owner?.kind === 'ComponentDeclaration' || owner?.kind === 'DecoratorDeclaration';
+    return component && block?.kind === 'BlockStatement'
+        ? ['select', ...COMPONENT_KEYWORDS]
+        : ['select'];
+}
+/** The nodes from `node` down to the identifier `name`, both included; empty if it is not there. */
+function pathTo(node, name) {
+    if (node.kind === 'Identifier' && node.name === name)
+        return [node];
+    let path = [];
+    forEachChild(node, (child) => {
+        if (path.length === 0) {
+            const below = pathTo(child, name);
+            if (below.length > 0)
+                path = [node, ...below];
+        }
+    });
+    return path;
+}
+/** The brackets that `text` opens and does not close, closed. */
+function unclosed(text) {
+    const open = [];
+    const pairs = { '(': ')', '[': ']', '{': '}' };
+    for (const { kind } of tokenize(text).tokens) {
+        if (kind in pairs)
+            open.push(pairs[kind]);
+        else if (kind === ')' || kind === ']' || kind === '}')
+            open.pop();
+    }
+    return open.reverse().join('');
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+/** Whether markup and components are on for a file. */
+export declare function markupFor(filename: string | undefined): boolean;

package/dist/config.js

@@ -0,0 +1,44 @@
+import { readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const DEFAULTS = { markup: false };
+/** package.json files read, with the time they were changed: the language server runs long. */
+const read = new Map();
+/** Whether markup and components are on for a file. */
+export function markupFor(filename) {
+    return settingsFor(resolve(filename ? dirname(filename) : '.')).markup;
+}
+function settingsFor(start) {
+    let dir = start;
+    while (true) {
+        const settings = readSettings(join(dir, 'package.json'));
+        if (settings)
+            return settings;
+        if (dirname(dir) === dir)
+            return DEFAULTS;
+        dir = dirname(dir);
+    }
+}
+/** The settings in a package.json, or null if there is none. */
+function readSettings(path) {
+    let changed;
+    try {
+        changed = statSync(path).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    const cached = read.get(path);
+    if (cached?.changed === changed)
+        return cached.settings;
+    let field;
+    try {
+        field = JSON.parse(readFileSync(path, 'utf8')).rook;
+    }
+    catch {
+        field = undefined;
+    }
+    const markup = typeof field === 'object' && field !== null && 'markup' in field && field.markup;
+    const settings = { markup: markup === true };
+    read.set(path, { changed, settings });
+    return settings;
+}

package/dist/css/hash.d.ts

@@ -0,0 +1 @@
+export declare function hash(text: string): string;

package/dist/css/hash.js

@@ -0,0 +1,10 @@
+// A short hash of CSS text for class names: FNV-1a, the same in Node and in the browser, so the
+// names do not depend on where or when the code is compiled.
+export function hash(text) {
+    let value = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        value ^= text.charCodeAt(i);
+        value = Math.imul(value, 0x01000193);
+    }
+    return (value >>> 0).toString(36);
+}

package/dist/css/parse.d.ts

@@ -0,0 +1,42 @@
+/** Stands for a value from code in the text of a style block. */
+export declare const SLOT = "\uE000";
+export interface CssRule {
+    kind: 'rule';
+    selector: string;
+    /** Offsets in the parsed text. */
+    start: number;
+    end: number;
+    body: CssNode[];
+}
+export interface CssAtRule {
+    kind: 'at-rule';
+    /** `media` for `@media (min-width: 600px) { ... }`. */
+    name: string;
+    prelude: string;
+    start: number;
+    end: number;
+    /** Null for a statement such as `@import url(a.css);`. */
+    body: CssNode[] | null;
+}
+export interface CssDeclaration {
+    kind: 'declaration';
+    property: string;
+    /** Text and the numbers of the values from code, in order: `0 {gap}px` → ["0 ", 0, "px"]. */
+    value: (string | number)[];
+    start: number;
+    end: number;
+}
+export type CssNode = CssRule | CssAtRule | CssDeclaration;
+export interface CssProblem {
+    message: string;
+    start: number;
+    end: number;
+}
+export interface CssSheet {
+    nodes: CssNode[];
+    problems: CssProblem[];
+}
+/** Parses CSS; values from code are SLOT characters, numbered in order. */
+export declare function parseCss(text: string): CssSheet;
+/** At-rules whose blocks hold rules with selectors of the page, such as `@media`. */
+export declare function holdsRules(rule: CssAtRule): boolean;

package/dist/css/parse.js

@@ -0,0 +1,138 @@
+// CSS as a tree of rules, at-rules and declarations: enough to rewrite selectors and to put values
+// from code into declarations. The text of selectors, at-rule preludes and values is kept as it is
+// written, without comments. A value from code is SLOT in the text given to the parser.
+/** Stands for a value from code in the text of a style block. */
+export const SLOT = '';
+/** Parses CSS; values from code are SLOT characters, numbered in order. */
+export function parseCss(text) {
+    const problems = [];
+    let pos = 0;
+    let slots = 0;
+    const skipSpace = () => {
+        while (pos < text.length) {
+            if (/\s/.test(text[pos])) {
+                pos++;
+            }
+            else if (text.startsWith('/*', pos)) {
+                const end = text.indexOf('*/', pos + 2);
+                pos = end === -1 ? text.length : end + 2;
+            }
+            else {
+                break;
+            }
+        }
+    };
+    /** Reads up to `{`, `;` or `}` outside strings and brackets; comments are left out. */
+    const readItem = () => {
+        let item = '';
+        let depth = 0;
+        while (pos < text.length) {
+            const c = text[pos];
+            if (text.startsWith('/*', pos)) {
+                const end = text.indexOf('*/', pos + 2);
+                pos = end === -1 ? text.length : end + 2;
+                item += ' ';
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                const start = pos;
+                pos++;
+                while (pos < text.length && text[pos] !== c && text[pos] !== '\n') {
+                    pos += text[pos] === '\\' ? 2 : 1;
+                }
+                pos++;
+                item += text.slice(start, pos);
+                continue;
+            }
+            if (c === '(' || c === '[')
+                depth++;
+            if (c === ')' || c === ']')
+                depth--;
+            if (depth <= 0 && (c === '{' || c === ';' || c === '}'))
+                break;
+            item += c;
+            pos++;
+        }
+        return item;
+    };
+    const block = (inRule) => {
+        const nodes = [];
+        while (true) {
+            skipSpace();
+            if (pos >= text.length || text[pos] === '}')
+                return nodes;
+            const start = pos;
+            const item = readItem().trim();
+            const end = pos;
+            const next = text[pos];
+            if (next === '{') {
+                pos++;
+                const body = block(true);
+                if (text[pos] === '}')
+                    pos++;
+                nodes.push(item.startsWith('@')
+                    ? { kind: 'at-rule', ...atRule(item), start, end, body }
+                    : { kind: 'rule', selector: item, start, end, body });
+                continue;
+            }
+            if (next === ';')
+                pos++;
+            if (item === '')
+                continue;
+            if (item.startsWith('@')) {
+                nodes.push({ kind: 'at-rule', ...atRule(item), start, end, body: null });
+                continue;
+            }
+            const colon = item.indexOf(':');
+            if (colon <= 0) {
+                problems.push({
+                    message: `expected a declaration such as "color: red", found "${item}"`,
+                    start,
+                    end,
+                });
+            }
+            else if (!inRule) {
+                problems.push({
+                    message: `a declaration needs a rule around it, e.g. .card { ${item} }`,
+                    start,
+                    end,
+                });
+            }
+            if (colon > 0) {
+                nodes.push({
+                    kind: 'declaration',
+                    property: item.slice(0, colon).trim(),
+                    value: valueParts(item.slice(colon + 1).trim()),
+                    start,
+                    end,
+                });
+            }
+        }
+    };
+    const valueParts = (value) => {
+        const parts = [];
+        value.split(SLOT).forEach((piece, i) => {
+            if (i > 0)
+                parts.push(slots++);
+            if (piece !== '')
+                parts.push(piece);
+        });
+        return parts;
+    };
+    const nodes = block(false);
+    while (pos < text.length) {
+        // A `}` without its `{`: report it and go on after it.
+        problems.push({ message: 'unexpected "}" in CSS', start: pos, end: pos + 1 });
+        pos++;
+        nodes.push(...block(false));
+    }
+    return { nodes, problems };
+}
+function atRule(item) {
+    const name = /^@([\w-]*)/.exec(item)[1];
+    return { name, prelude: item.slice(name.length + 1).trim() };
+}
+/** At-rules whose blocks hold rules with selectors of the page, such as `@media`. */
+export function holdsRules(rule) {
+    return ['media', 'supports', 'container', 'layer', 'scope', 'document'].includes(rule.name);
+}

package/dist/css/print.d.ts

@@ -0,0 +1,9 @@
+import { type CssDeclaration, type CssNode } from './parse.ts';
+export interface PrintOptions {
+    /** The selector of a rule; not called inside `@keyframes`, whose selectors are steps. */
+    selector: (selector: string) => string;
+    value: (declaration: CssDeclaration) => string;
+}
+export declare function printCss(nodes: readonly CssNode[], options: PrintOptions): string;
+/** The text of a value with its values from code given by `slot`. */
+export declare function valueText(declaration: CssDeclaration, slot: (index: number) => string): string;

package/dist/css/print.js

@@ -0,0 +1,35 @@
+import { holdsRules } from "./parse.js";
+export function printCss(nodes, options) {
+    const lines = [];
+    const print = (list, indent, steps) => {
+        for (const node of list) {
+            switch (node.kind) {
+                case 'declaration':
+                    lines.push(`${indent}${node.property}: ${options.value(node)};`);
+                    break;
+                case 'rule':
+                    lines.push(`${indent}${steps ? node.selector : options.selector(node.selector)} {`);
+                    print(node.body, `${indent}  `, steps);
+                    lines.push(`${indent}}`);
+                    break;
+                case 'at-rule': {
+                    const head = `${indent}@${node.name}${node.prelude ? ` ${node.prelude}` : ''}`;
+                    if (node.body === null) {
+                        lines.push(`${head};`);
+                        break;
+                    }
+                    lines.push(`${head} {`);
+                    // The rules of @media keep their selectors; @keyframes has steps, @font-face none.
+                    print(node.body, `${indent}  `, steps || !holdsRules(node));
+                    lines.push(`${indent}}`);
+                }
+            }
+        }
+    };
+    print(nodes, '', false);
+    return lines.join('\n');
+}
+/** The text of a value with its values from code given by `slot`. */
+export function valueText(declaration, slot) {
+    return declaration.value.map((part) => (typeof part === 'number' ? slot(part) : part)).join('');
+}

package/dist/css/selectors.d.ts

@@ -0,0 +1,29 @@
+/** A selector list split at the commas outside brackets. */
+export declare function splitList(selector: string): string[];
+/**
+ * A complex selector as compound selectors and the combinators between them:
+ * `ul > li.item a` → ["ul", " > ", "li.item", " ", "a"]. A relative selector starts with a
+ * combinator: `> a` → ["", "> ", "a"].
+ */
+export declare function splitComplex(selector: string): string[];
+/**
+ * Gives every compound selector the class of a component, before its pseudo-elements, so that the
+ * rule applies only to its elements. Compounds with `&` refer to the rule around them, and those
+ * in `:global(...)` are left to the page.
+ */
+export declare function scopeSelector(selector: string, scope: string): string;
+/** `:global(.a) .b` → `.a .b`. */
+export declare function unwrapGlobal(selector: string): string;
+/**
+ * The classes of a CSS module get its names: `.button:hover` → `.button_k3f9:hover`. Classes in
+ * `:global(...)` keep their names. Calls `found` for every local class.
+ */
+export declare function renameClasses(selector: string, rename: (name: string) => string, found: (name: string) => void): string;
+/** What a compound selector asks of an element, for checking that some element can match it. */
+export interface CompoundRequirements {
+    tag: string | null;
+    classes: string[];
+    ids: string[];
+}
+/** The tag, classes and ids a compound requires; those inside `:not(...)` and others are not. */
+export declare function requirements(compound: string): CompoundRequirements;