@lwc-bolts/sf2ts 0.0.5 → 1.0.0

package/dist/lightning-component-bundle/component-source.js

@@ -0,0 +1,21 @@
+// Parsing component source (JavaScript or TypeScript), for the one fact sf2ts reads from it: its default
+// export's name.
+import { tsPlugin } from "@sveltejs/acorn-typescript";
+import { Parser } from "acorn";
+/**
+ * acorn with TypeScript syntax, which also parses decorators (`@api`, `@wire`). JavaScript components
+ * are parsed with it too, since plain acorn rejects decorators.
+ */
+const ComponentParser = Parser.extend(tsPlugin());
+/**
+ * Parses a component's module, or returns undefined when it doesn't parse (such as a file being edited),
+ * so callers find nothing in it rather than guessing.
+ */
+export function parseComponentSource(source) {
+    try {
+        return ComponentParser.parse(source, { ecmaVersion: "latest", sourceType: "module" });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lightning-component-bundle/metadata.d.ts

@@ -0,0 +1,36 @@
+import type { ConversionContext } from "../context.ts";
+import type { ConversionOutput, LightningComponentBundleComponent } from "../types.ts";
+/**
+ * Declares the `c/<name>` module that LWC components import another component through, from the
+ * component's `<name>.js-meta.xml`. The declaration re-exports the component's own module by type,
+ * so its default and named exports keep their types and definitions, without listing them:
+ *
+ * ```ts
+ * declare module "c/myComponent" {
+ *   const myComponent: typeof import("./myComponent.js");
+ *   export = myComponent;
+ * }
+ * ```
+ *
+ * The declaration's variable is named after the module's default export (`component.defaultExportName`),
+ * which editors suggest when auto-importing it, or after the bundle without one.
+ *
+ * A bundle of another namespace (an installed package's, named `dlrs__manageRollups`) is imported
+ * through its namespace, as `dlrs/manageRollups`, and only when it's exposed (`<isExposed>true`); other
+ * namespaces can't import it otherwise, so it declares nothing. A template's tag names its namespace in
+ * lower case (`<sbqq-quote-line>`), so a namespace that isn't (`SBQQ`) is declared that way too.
+ */
+export declare function convertBundleMetadata(component: LightningComponentBundleComponent, context: ConversionContext): ConversionOutput;
+/**
+ * A bundle's API version, from its `.js-meta.xml`, or undefined when it has none that can be read (such
+ * as one being written).
+ */
+export declare function bundleApiVersion(metadata: string): number | undefined;
+/**
+ * Finds the name of a module's default export: a named class or function, an identifier
+ * (`export default recordCard;`), or `export { recordCard as default }`, optionally re-exported from
+ * another module. Returns undefined for anonymous defaults (`export default class extends ...`, arrow
+ * functions, objects, calls, any other expression), `export { default } from "..."`, modules without a
+ * default export, and modules that don't parse.
+ */
+export declare function findDefaultExportName(source: string): string | undefined;

package/dist/lightning-component-bundle/metadata.js

@@ -0,0 +1,93 @@
+import { importNameParts, metadataName } from "../names.js";
+import { parseComponentSource } from "./component-source.js";
+import { variableName } from "../identifiers.js";
+import { docParagraphs, docTag, jsDoc } from "../jsdoc.js";
+import { TextBuilder } from "../text-builder.js";
+import { parseXml } from "../xml.js";
+/**
+ * Declares the `c/<name>` module that LWC components import another component through, from the
+ * component's `<name>.js-meta.xml`. The declaration re-exports the component's own module by type,
+ * so its default and named exports keep their types and definitions, without listing them:
+ *
+ * ```ts
+ * declare module "c/myComponent" {
+ *   const myComponent: typeof import("./myComponent.js");
+ *   export = myComponent;
+ * }
+ * ```
+ *
+ * The declaration's variable is named after the module's default export (`component.defaultExportName`),
+ * which editors suggest when auto-importing it, or after the bundle without one.
+ *
+ * A bundle of another namespace (an installed package's, named `dlrs__manageRollups`) is imported
+ * through its namespace, as `dlrs/manageRollups`, and only when it's exposed (`<isExposed>true`); other
+ * namespaces can't import it otherwise, so it declares nothing. A template's tag names its namespace in
+ * lower case (`<sbqq-quote-line>`), so a namespace that isn't (`SBQQ`) is declared that way too.
+ */
+export function convertBundleMetadata(component, context) {
+    // read leniently: a .js-meta.xml being written still declares its bundle's module
+    const root = parseXml(component.content);
+    const bundle = root?.name === "LightningComponentBundle" ? root : undefined;
+    const fileName = metadataName(component.path);
+    const { namespace, name } = importNameParts(fileName, context.projectNamespace);
+    if (namespace !== undefined && bundle?.childText("isExposed")?.trim() !== "true") {
+        return { text: "", mapData: [] };
+    }
+    const label = bundle?.childText("masterLabel");
+    const description = docTag("description", bundle?.childText("description"));
+    // go-to-definition on the module's name lands on the label, or on the root element without one
+    const range = bundle?.child("masterLabel")?.contentRange ?? bundle?.nameRange;
+    const variable = variableName(component.defaultExportName ?? name);
+    const builder = new TextBuilder();
+    const modules = new Set([`${namespace ?? "c"}/${name}`, ...(namespace === undefined ? [] : [`${namespace.toLowerCase()}/${name}`])]);
+    for (const module of modules) {
+        builder.write(jsDoc("", docParagraphs(label, description)));
+        builder.write("declare module ");
+        builder.writeMapped(JSON.stringify(module), range);
+        builder.write(` {
+  const ${variable}: typeof import("./${fileName}.js");
+  export = ${variable};
+}
+`);
+    }
+    return builder.output();
+}
+/**
+ * A bundle's API version, from its `.js-meta.xml`, or undefined when it has none that can be read (such
+ * as one being written).
+ */
+export function bundleApiVersion(metadata) {
+    const root = parseXml(metadata);
+    const version = root?.name === "LightningComponentBundle" ? Number(root.childText("apiVersion")?.trim() || NaN) : NaN;
+    return Number.isFinite(version) ? version : undefined;
+}
+/**
+ * Finds the name of a module's default export: a named class or function, an identifier
+ * (`export default recordCard;`), or `export { recordCard as default }`, optionally re-exported from
+ * another module. Returns undefined for anonymous defaults (`export default class extends ...`, arrow
+ * functions, objects, calls, any other expression), `export { default } from "..."`, modules without a
+ * default export, and modules that don't parse.
+ */
+export function findDefaultExportName(source) {
+    for (const statement of parseComponentSource(source)?.body ?? []) {
+        if (statement.type === "ExportDefaultDeclaration") {
+            const { declaration } = statement;
+            const name = declaration.type === "Identifier"
+                ? declaration.name
+                : declaration.type === "ClassDeclaration" || declaration.type === "FunctionDeclaration"
+                    ? declaration.id?.name
+                    : undefined;
+            // `undefined` is an identifier, but no name for a variable
+            return name === "undefined" ? undefined : name;
+        }
+        if (statement.type === "ExportNamedDeclaration") {
+            for (const { local, exported } of statement.specifiers) {
+                const exportedName = exported.type === "Identifier" ? exported.name : exported.value;
+                if (exportedName === "default" && local.type === "Identifier" && local.name !== "default") {
+                    return local.name;
+                }
+            }
+        }
+    }
+    return undefined;
+}

package/dist/lightning-component-bundle/templates/ast.d.ts

@@ -0,0 +1,47 @@
+import type { ChildNode, ComplexExpression, ElseBlock, ElseifBlock, Expression, ForEach, ForOf, If, IfBlock, Literal, Root } from "@lwc/template-compiler/dist/shared/types.js";
+export type { BaseElement, ChildNode, ElseifBlock, ForEach, ForOf, If, IfBlock, Property, Root, ScopedSlotFragment, SourceLocation, Text, } from "@lwc/template-compiler/dist/shared/types.js";
+/** Whether a component at an API version has complex expressions: the latest does, when it's not known. */
+export declare function hasComplexExpressions(apiVersion: number | undefined): boolean;
+/**
+ * A parsed expression: an ESTree node, which the compiler's types leave without its offsets. In an
+ * attribute or directive they're relative to its `{`. Where they're relative to in text depends on the API
+ * version (see TemplateSource.textExpression).
+ */
+export type TemplateExpression = (Expression | ComplexExpression) & {
+    start: number;
+    end: number;
+};
+/** What an attribute, directive or text has: an expression, or a literal the compiler made of it. */
+export type TemplateValue = Literal | Expression | ComplexExpression;
+/** Whether a value is an expression, rather than the literal the compiler made of an attribute or text. */
+export declare function isExpression(value: TemplateValue): value is TemplateExpression;
+/** Nodes that don't create elements, so their content is their parent's content. */
+export declare function isBlock(node: ChildNode): node is IfBlock | ElseifBlock | ElseBlock | If | ForEach | ForOf;
+/** A diagnostic from the compiler, whose own type doesn't resolve either. */
+export interface CompilerDiagnostic {
+    message: string;
+    level: number;
+    location?: {
+        start?: number;
+        length?: number;
+    };
+}
+/** A parsed template: as much of it as the compiler could read, and its errors, without its warnings. */
+export interface ParsedTemplate {
+    root: Root | undefined;
+    errors: CompilerDiagnostic[];
+}
+/** What sf2ts uses the compiler for, which is where it's reached from. */
+export interface TemplateCompiler {
+    /** Parses a template at an API version (see parseConfig). */
+    parse(source: string, apiVersion: number | undefined): ParsedTemplate;
+    /**
+     * The expression as LWC's codegen binds it: an ESTree node with each of the component's members wrapped
+     * in a member expression of `instance`. It throws for what only codegen rejects.
+     */
+    bind(expression: TemplateExpression, isLocal: (name: string) => boolean, instance: string, complexExpressions: boolean): unknown;
+    /** The module of a component's tag: `c-base-card` is `c/baseCard`. */
+    tagModule(tag: string): string;
+}
+/** Loads the compiler, on the first template. */
+export declare function loadTemplateCompiler(): Promise<TemplateCompiler>;

package/dist/lightning-component-bundle/templates/ast.js

@@ -0,0 +1,46 @@
+/** The API version that complex expressions start at. */
+const COMPLEX_EXPRESSIONS_API_VERSION = 66;
+/** Whether a component at an API version has complex expressions: the latest does, when it's not known. */
+export function hasComplexExpressions(apiVersion) {
+    return apiVersion === undefined || apiVersion >= COMPLEX_EXPRESSIONS_API_VERSION;
+}
+/**
+ * How a template is parsed: at its component's API version, as the compiler gates what's valid by it, or
+ * without one (a component whose metadata can't be read) at the compiler's latest. Complex expressions
+ * also need their flag, as it changes what's valid at older versions: with it, `"{x}"` is a binding, rather
+ * than an ambiguity the compiler reports.
+ */
+function parseConfig(apiVersion) {
+    return {
+        experimentalComplexExpressions: hasComplexExpressions(apiVersion),
+        enableDynamicComponents: true,
+        enableLwcOn: true,
+        ...(apiVersion !== undefined && { apiVersion }),
+    };
+}
+/** Whether a value is an expression, rather than the literal the compiler made of an attribute or text. */
+export function isExpression(value) {
+    return "start" in value;
+}
+/** Nodes that don't create elements, so their content is their parent's content. */
+export function isBlock(node) {
+    return ["IfBlock", "ElseifBlock", "ElseBlock", "If", "ForEach", "ForOf"].includes(node.type);
+}
+/** Whether the compiler's diagnostic is an error. Its levels: 0 fatal, 1 error, 2 warning, 3 log. */
+function isError(diagnostic) {
+    return diagnostic.level <= 1;
+}
+let compiler;
+/** Loads the compiler, on the first template. */
+export async function loadTemplateCompiler() {
+    compiler ??= import("@lwc/template-compiler");
+    const { bindExpression, kebabcaseToCamelcase, parse } = await compiler;
+    return {
+        parse(source, apiVersion) {
+            const { root, warnings } = parse(source, parseConfig(apiVersion));
+            return { root, errors: warnings.filter(isError) };
+        },
+        bind: (expression, isLocal, instance, complexExpressions) => bindExpression(expression, (node) => isLocal(node.name), instance, complexExpressions),
+        tagModule: kebabcaseToCamelcase,
+    };
+}

package/dist/lightning-component-bundle/templates/base-components.d.ts

@@ -0,0 +1,6 @@
+import type { LightningComponent } from "@lwc-bolts/lightning-base-components";
+/**
+ * A base component's types, named after `alias`: its properties (`<alias>`, with the host element's),
+ * and when it has any, its methods (`<alias>Methods`, which refs use).
+ */
+export declare function baseComponentTypes(alias: string, component: LightningComponent): string;

package/dist/lightning-component-bundle/templates/base-components.js

@@ -0,0 +1,17 @@
+/**
+ * A base component's types, named after `alias`: its properties (`<alias>`, with the host element's),
+ * and when it has any, its methods (`<alias>Methods`, which refs use).
+ */
+export function baseComponentTypes(alias, component) {
+    const members = (record, optional) => Object.entries(record)
+        .map(([name, { type, description }]) => {
+        const doc = description ? `  /** ${description.replace(/\*\//g, "*\\/")} */\n` : "";
+        return `${doc}  ${JSON.stringify(name)}${optional ? "?" : ""}: ${type};\n`;
+    })
+        .join("");
+    let types = `type ${alias} = {\n${members(component.properties, true)}} & __lwcHostProperties;\n`;
+    if (Object.keys(component.methods).length > 0) {
+        types += `type ${alias}Methods = {\n${members(component.methods, false)}};\n`;
+    }
+    return types;
+}

package/dist/lightning-component-bundle/templates/declarations.d.ts

@@ -0,0 +1,30 @@
+import type { LightningComponent } from "@lwc-bolts/lightning-base-components";
+import type { BaseElement } from "./ast.ts";
+import type { Writer } from "./writer.ts";
+/** The type aliases of the components a template uses, each declared once. */
+export declare class ComponentTypes {
+    #private;
+    constructor(baseComponents: Readonly<Record<string, LightningComponent>>);
+    /** The alias of a child component's class: `module` is its module, such as `c/baseCard` or an installed package's `dlrs/manageRollups`. */
+    component(module: string, node: BaseElement): string;
+    /** The alias of a base component's properties. */
+    base(tag: string): string;
+    /**
+     * Declares the aliases. A tag maps to both the module, so a component that doesn't exist is reported on
+     * it and hovering it shows the component's label, and its default export, so go-to-definition opens the
+     * class rather than the module's .js-meta.xml.
+     */
+    write(out: Writer): void;
+}
+/** `lwc:ref` names, with the types of the elements they name and where the template names them. */
+export declare class TemplateRefs {
+    #private;
+    add(name: string, type: string, optional: boolean, position: number | undefined): void;
+    /**
+     * Augments the component's module so `this.refs` has them. Every template of a bundle declares the same
+     * `refs` type, over the `__LwcRefs` interface that each adds its own refs to, so a bundle's templates
+     * don't conflict. It's a mapped type over the interface, since `LightningElement`'s `refs` has an index
+     * signature, which an object type satisfies and an interface doesn't.
+     */
+    write(out: Writer, componentModule: string): void;
+}

package/dist/lightning-component-bundle/templates/declarations.js

@@ -0,0 +1,82 @@
+import { MapFeature } from "../../text-builder.js";
+import { baseComponentTypes } from "./base-components.js";
+/** The type aliases of the components a template uses, each declared once. */
+export class ComponentTypes {
+    /** Child components by module name, with where the first tag is. */
+    #components = new Map();
+    /** Base components by tag. */
+    #lightning = new Map();
+    #baseComponents;
+    constructor(baseComponents) {
+        this.#baseComponents = baseComponents;
+    }
+    /** The alias of a child component's class: `module` is its module, such as `c/baseCard` or an installed package's `dlrs/manageRollups`. */
+    component(module, node) {
+        let component = this.#components.get(module);
+        if (component === undefined) {
+            // the tag's name, after its `<`, so a component that doesn't exist is reported on the tag
+            component = { alias: `__lwcComponent${this.#components.size}`, position: node.location.start + 1, length: node.name.length };
+            this.#components.set(module, component);
+        }
+        return component.alias;
+    }
+    /** The alias of a base component's properties. */
+    base(tag) {
+        let alias = this.#lightning.get(tag);
+        if (alias === undefined) {
+            alias = `__lwcLightning${this.#lightning.size}`;
+            this.#lightning.set(tag, alias);
+        }
+        return alias;
+    }
+    /**
+     * Declares the aliases. A tag maps to both the module, so a component that doesn't exist is reported on
+     * it and hovering it shows the component's label, and its default export, so go-to-definition opens the
+     * class rather than the module's .js-meta.xml.
+     */
+    write(out) {
+        for (const [module, { alias, position, length }] of this.#components) {
+            out.write(`type ${alias} = typeof import(`);
+            out.writeAt(JSON.stringify(module), position, length, MapFeature.All & ~MapFeature.Definition);
+            out.write(").");
+            out.writeAt("default", position, length, MapFeature.Definition);
+            out.write(";\n");
+        }
+        for (const [tag, alias] of this.#lightning) {
+            out.write(baseComponentTypes(alias, this.#baseComponents[tag]));
+        }
+    }
+}
+/** `lwc:ref` names, with the types of the elements they name and where the template names them. */
+export class TemplateRefs {
+    #refs = new Map();
+    add(name, type, optional, position) {
+        const ref = this.#refs.get(name) ?? { types: new Set(), optional: false, position };
+        ref.types.add(type);
+        ref.optional ||= optional;
+        this.#refs.set(name, ref);
+    }
+    /**
+     * Augments the component's module so `this.refs` has them. Every template of a bundle declares the same
+     * `refs` type, over the `__LwcRefs` interface that each adds its own refs to, so a bundle's templates
+     * don't conflict. It's a mapped type over the interface, since `LightningElement`'s `refs` has an index
+     * signature, which an object type satisfies and an interface doesn't.
+     */
+    write(out, componentModule) {
+        if (this.#refs.size === 0) {
+            return;
+        }
+        out.write(`declare module ${JSON.stringify(componentModule)} {
+  export default interface __LwcTemplate {
+    refs: { [K in keyof __LwcRefs]: __LwcRefs[K] } | undefined;
+  }
+  export interface __LwcRefs {
+`);
+        for (const [name, { types, optional, position }] of this.#refs) {
+            out.write("    ");
+            out.writeAt(name, position, name.length);
+            out.write(`${optional ? "?" : ""}: ${[...types].join(" | ")};\n`);
+        }
+        out.write("  }\n}\n");
+    }
+}

package/dist/lightning-component-bundle/templates/expressions.d.ts

@@ -0,0 +1,16 @@
+import type { TemplateCompiler, TemplateExpression } from "./ast.ts";
+/** A name in an expression that's a member of the component. */
+export interface ComponentName {
+    start: number;
+    end: number;
+    /** Whether it's a shorthand property (`{ a }`), which needs its key spelled out to be prefixed. */
+    shorthand: boolean;
+}
+/**
+ * The names in an expression that are members of the component, in order, as LWC's codegen binds them.
+ * `bind` wraps each one in a member expression of an instance it makes up, which has no offsets, while
+ * the name itself keeps its own. It throws for an expression that only codegen rejects.
+ */
+export declare function componentNames(expression: TemplateExpression, isLocal: (name: string) => boolean, complexExpressions: boolean, bind: TemplateCompiler["bind"]): ComponentName[];
+/** Whether an expression is one that's safe anywhere: others are parenthesized where they're written. */
+export declare function isSimple(expression: TemplateExpression): boolean;

package/dist/lightning-component-bundle/templates/expressions.js

@@ -0,0 +1,33 @@
+function isNode(value) {
+    return value !== null && typeof value === "object" && typeof value.type === "string";
+}
+function children(node) {
+    return Object.values(node).flat().filter(isNode);
+}
+/** Marks the names LWC binds to the component in an expression: nothing else is called this. */
+const INSTANCE = "$cmp";
+/**
+ * The names in an expression that are members of the component, in order, as LWC's codegen binds them.
+ * `bind` wraps each one in a member expression of an instance it makes up, which has no offsets, while
+ * the name itself keeps its own. It throws for an expression that only codegen rejects.
+ */
+export function componentNames(expression, isLocal, complexExpressions, bind) {
+    const names = [];
+    const visit = (node, parent) => {
+        const object = node.type === "MemberExpression" ? node.object : undefined;
+        if (object?.name === INSTANCE && object.start === undefined) {
+            const { start, end } = node.property;
+            names.push({ start, end, shorthand: parent?.type === "Property" && parent.shorthand === true });
+            return;
+        }
+        for (const child of children(node)) {
+            visit(child, node);
+        }
+    };
+    visit(bind(expression, isLocal, INSTANCE, complexExpressions), undefined);
+    return names.sort((a, b) => a.start - b.start);
+}
+/** Whether an expression is one that's safe anywhere: others are parenthesized where they're written. */
+export function isSimple(expression) {
+    return expression.type === "Identifier" || expression.type === "MemberExpression";
+}

package/dist/lightning-component-bundle/templates/helpers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Declarations the converted code can use, by the name each declares. A template's TypeScript declares
+ * the ones it uses, after its code.
+ */
+export declare const TEMPLATE_HELPERS: Readonly<Record<string, string>>;
+/**
+ * The declarations of the helpers `text` uses, in TEMPLATE_HELPERS' order, in one pass over it. Helpers
+ * only use themselves, so the ones `text` names are all it needs.
+ */
+export declare function helperDeclarations(text: string): string;

package/dist/lightning-component-bundle/templates/helpers.js

@@ -0,0 +1,47 @@
+// Utility types templates might use, which are dynamically added to each component that uses them
+/**
+ * Declarations the converted code can use, by the name each declares. A template's TypeScript declares
+ * the ones it uses, after its code.
+ */
+export const TEMPLATE_HELPERS = {
+    __lwcElement: `type __lwcElement<T extends string> = T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : HTMLElement;
+`,
+    __lwcSvgElement: `type __lwcSvgElement<T extends string> = T extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[T] : SVGElement;
+`,
+    __lwcMathElement: `type __lwcMathElement<T extends string> = T extends keyof MathMLElementTagNameMap ? MathMLElementTagNameMap[T] : MathMLElement;
+`,
+    __lwcHostProperties: `type __lwcHostProperties = Partial<
+  Pick<HTMLElement, "id" | "title" | "hidden" | "tabIndex" | "accessKey" | "dir" | "lang" | "draggable" | "spellcheck" | "autofocus">
+> &
+  Partial<ARIAMixin>;
+`,
+    __lwcProperties: `// \`constructor\` is a property of LightningElement, which an object literal's own constructor doesn't match
+type __lwcProperties<T> = Partial<Omit<T, "constructor">>;
+`,
+    __lwcSlots: `declare global {
+  /** The slots of the components whose templates are in the program, which each template adds its own to. */
+  interface __LwcSlots {}
+}
+/** The slots of the component M (such as "c/baseCard"), or any slot when they aren't known. */
+type __lwcSlots<M extends string, K = keyof __LwcSlots> = \`\${M} *\` extends keyof __LwcSlots
+  ? string
+  : M extends keyof __LwcSlots
+    ? K extends \`\${M} \${infer S}\`
+      ? S
+      : never
+    : string;
+`,
+};
+/** Finds each helper's name as a whole word (`__lwcElement`, not `__lwcElements`). */
+const HELPER_NAMES = new RegExp(`\\b(?:${Object.keys(TEMPLATE_HELPERS).join("|")})\\b`, "g");
+/**
+ * The declarations of the helpers `text` uses, in TEMPLATE_HELPERS' order, in one pass over it. Helpers
+ * only use themselves, so the ones `text` names are all it needs.
+ */
+export function helperDeclarations(text) {
+    const used = new Set(text.match(HELPER_NAMES));
+    return Object.keys(TEMPLATE_HELPERS)
+        .filter((name) => used.has(name))
+        .map((name) => TEMPLATE_HELPERS[name])
+        .join("");
+}

package/dist/lightning-component-bundle/templates/slots.d.ts

@@ -0,0 +1,24 @@
+import { type BaseElement, type Root } from "./ast.ts";
+import type { TemplateSource } from "./source.ts";
+/** A slot name in a slot check, with `(default)` for the unnamed slot. */
+export declare const DEFAULT_SLOT = "(default)";
+/** The slots a template declares, `(default)` for the unnamed one. */
+export declare function templateSlots(root: Root): Set<string>;
+/**
+ * Declares a template's slots for the templates that use its component, `module` (such as `c/baseCard`),
+ * which check what they pass it against `__lwcSlots<"c/baseCard">`. Each of the component's templates adds
+ * to the global `__LwcSlots` interface: `"c/baseCard"`, saying its slots are known, and `"c/baseCard footer"`
+ * for each slot. Slots are `undefined` when the template has errors (such as one being edited), whose slots
+ * may be missing: it adds `"c/baseCard *"`, which allows any slot. A component without templates in the
+ * program adds nothing, and isn't checked.
+ */
+export declare function slotDeclarations(module: string, slots: ReadonlySet<string> | undefined): string;
+/** A piece of content passed to a component, naming the slot it goes in. */
+export interface SlottedContent {
+    slot: string;
+    /** Where to report a slot that doesn't exist, when that can be found. */
+    position: number | undefined;
+    length: number;
+}
+/** The content a component's tag passes to it: `lwc:if` and loops don't create elements, so theirs is too. */
+export declare function slottedContent(node: BaseElement, source: TemplateSource): SlottedContent[];

package/dist/lightning-component-bundle/templates/slots.js

@@ -0,0 +1,78 @@
+// Slots: those a template declares, for templates that use its component, and the content a template
+// passes to a child's.
+import { isBlock } from "./ast.js";
+/** A slot name in a slot check, with `(default)` for the unnamed slot. */
+export const DEFAULT_SLOT = "(default)";
+/** The slots a template declares, `(default)` for the unnamed one. */
+export function templateSlots(root) {
+    const slots = new Set();
+    const visit = (node) => {
+        if (node === undefined || node.type === "Text" || node.type === "Comment")
+            return;
+        if (node.type === "Slot") {
+            slots.add(node.slotName || DEFAULT_SLOT);
+        }
+        node.children.forEach(visit);
+        if ("else" in node)
+            visit(node.else);
+    };
+    root.children.forEach(visit);
+    return slots;
+}
+/**
+ * Declares a template's slots for the templates that use its component, `module` (such as `c/baseCard`),
+ * which check what they pass it against `__lwcSlots<"c/baseCard">`. Each of the component's templates adds
+ * to the global `__LwcSlots` interface: `"c/baseCard"`, saying its slots are known, and `"c/baseCard footer"`
+ * for each slot. Slots are `undefined` when the template has errors (such as one being edited), whose slots
+ * may be missing: it adds `"c/baseCard *"`, which allows any slot. A component without templates in the
+ * program adds nothing, and isn't checked.
+ */
+export function slotDeclarations(module, slots) {
+    const keys = [module, ...(slots === undefined ? [`${module} *`] : [...slots].map((slot) => `${module} ${slot}`))];
+    return `declare global {
+  interface __LwcSlots {
+${keys.map((key) => `    ${JSON.stringify(key)}: true;\n`).join("")}  }
+}
+`;
+}
+/** The content a component's tag passes to it: `lwc:if` and loops don't create elements, so theirs is too. */
+export function slottedContent(node, source) {
+    const nodes = [];
+    const collect = (children) => {
+        for (const child of children) {
+            if (isBlock(child)) {
+                collect(child.children);
+                if ("else" in child && child.else)
+                    collect([child.else]);
+            }
+            else {
+                nodes.push(child);
+            }
+        }
+    };
+    collect(node.children);
+    return nodes.flatMap((child) => contentOf(child, source) ?? []);
+}
+/** What a node passes to a slot, if anything: a slot chosen at runtime can't be checked. */
+function contentOf(child, source) {
+    if (child.type === "Comment" || isBlock(child)) {
+        return undefined;
+    }
+    if (child.type === "Text") {
+        const text = child.raw.trim();
+        return text === "" ? undefined : { slot: DEFAULT_SLOT, position: source.literal(text, child.location), length: text.length };
+    }
+    if (child.type === "ScopedSlotFragment") {
+        const name = child.slotName;
+        return name.type === "Literal" ? { slot: String(name.value) || DEFAULT_SLOT, position: undefined, length: 0 } : undefined;
+    }
+    const attribute = child.attributes.find(({ name }) => name === "slot");
+    if (attribute === undefined) {
+        return { slot: DEFAULT_SLOT, position: child.location.start + 1, length: child.name.length };
+    }
+    const { value } = attribute;
+    if (value.type !== "Literal" || typeof value.value !== "string") {
+        return undefined;
+    }
+    return { slot: value.value || DEFAULT_SLOT, position: source.name(value.value, attribute.location, "="), length: value.value.length };
+}

package/dist/lightning-component-bundle/templates/source.d.ts

@@ -0,0 +1,36 @@
+import type { SourceLocation, TemplateExpression } from "./ast.ts";
+/** An expression's place in the template. */
+export interface ExpressionOrigin {
+    /** The `{` of the expression, which `$cmp.` maps to, so a problem with a whole expression starts there. */
+    brace: number;
+    /** The template offset of one of the offsets the expression's nodes have. */
+    at(offset: number): number;
+}
+/** How a template was parsed, which changes what the compiler says about it. */
+export interface TemplateSourceOptions {
+    /** Whether it was parsed with complex expressions, which changes how it renders. */
+    complexExpressions: boolean;
+}
+export declare class TemplateSource {
+    #private;
+    readonly text: string;
+    constructor(text: string, options: TemplateSourceOptions);
+    /** The expression in an attribute or directive spanning `location`, if there is one. */
+    attribute(location: SourceLocation): ExpressionOrigin | undefined;
+    /**
+     * The expression of the next text node in a run of text, or undefined for a literal, which only moves
+     * the cursor. The compiler tidies a run's lines before parsing it, so a node's `raw` is in that text, not
+     * the template's.
+     *
+     * Without complex expressions, an expression is on one line, so `raw` is in the template as it is, and
+     * its offsets are relative to `raw`.
+     *
+     * With them, its offsets are relative to the tidied run. Each `{` in the text starts an expression, so
+     * the next one is this node's, and from it `raw` lines up with the template but for whitespace.
+     */
+    textExpression(raw: string, expression: TemplateExpression | undefined, location: SourceLocation): ExpressionOrigin | undefined;
+    /** The offset of some literal text in a run of text, if it's there as it is. */
+    literal(text: string, location: SourceLocation): number | undefined;
+    /** The offset of a name in an attribute such as `for:item="row"`, after its `=` (or its `:`). */
+    name(name: string, location: SourceLocation, after: "=" | ":"): number | undefined;
+}