forgebook 0.3.2 → 0.4.0

package/dist/src/vite/configKeys.js

@@ -0,0 +1,171 @@
+/**
+ * The keys a catalogue's configuration and a library's preset may have, and what to say of one they may not.
+ *
+ * @remarks
+ * A configuration is code nobody type-checked against this version, and a misspelt key is otherwise read as a value left
+ * out: `toolbr: […]` gives the default toolbar, with no word of why. Nothing can add a key: an adapter's and a plugin's
+ * options are the arguments of their own functions (`react({ … })`, `figma({ … })`), and both reach the catalogue as one
+ * value of `framework` and `plugins`. So the lists are closed, and written as records of the types' own keys: a key added
+ * to a type without being added here does not compile.
+ *
+ * The objects read here by key (`build`, `appBuild`, `shell`, `a11y`, `backgrounds`, `widthRange`, `controls`) are checked one level
+ * down, and each of `refs` by its id. `tabs` is not, since a plugin adds to its names; a device's fields have their own check (`configFile.ts`), and a
+ * theme's values theirs (`shellTheme.ts`).
+ *
+ * @module
+ */
+import { didYouMean } from "@ensiria/cli-kit/suggest";
+import { OWN_CONTROL_IDS } from "../catalogue.js";
+/** What a catalogue's configuration and a preset share. */
+const LIST_KEYS = {
+    id: true,
+    widths: true,
+    widthRange: true,
+    zooms: true,
+    textSizes: true,
+    backgrounds: true,
+    storyGroups: true,
+    tabs: true,
+    a11y: true,
+    gridStep: true,
+    strings: true,
+    keys: true,
+    controls: true,
+    toolbar: true,
+    usedIn: true,
+    play: true,
+    componentDocs: true,
+    audience: true,
+    appearance: true,
+    propGroups: true,
+    requiredFirst: true,
+    views: true,
+    device: true,
+    statuses: true
+};
+/** A configuration's keys. */
+const CONFIG_KEYS = {
+    ...LIST_KEYS,
+    framework: true,
+    title: true,
+    logo: true,
+    heights: true,
+    stories: true,
+    docs: true,
+    home: true,
+    sources: true,
+    switches: true,
+    languages: true,
+    shell: true,
+    tokens: true,
+    argControls: true,
+    preview: true,
+    head: true,
+    watch: true,
+    presets: true,
+    plugins: true,
+    frames: true,
+    build: true,
+    appBuild: true,
+    refs: true
+};
+/** A preset's keys. */
+const PRESET_KEYS = {
+    ...LIST_KEYS,
+    name: true,
+    switches: true,
+    languages: true,
+    preview: true,
+    head: true,
+    shell: true
+};
+const BUILD_KEYS = { readableNames: true };
+const APP_BUILD_KEYS = {
+    viteConfig: true,
+    tsconfigPaths: true,
+    postcss: true,
+    skipPlugins: true,
+    keepPlugins: true
+};
+const SHELL_KEYS = { theme: true, css: true, branding: true };
+const REF_KEYS = { title: true, url: true };
+const A11Y_KEYS = {
+    tags: true,
+    disabledRules: true
+};
+const BACKGROUND_KEYS = { builtIn: true, custom: true };
+const WIDTH_RANGE_KEYS = { min: true, max: true };
+/** What `controls` can turn off, Forgebook's own controls first. */
+const TURNED_OFF_CONTROLS = [...OWN_CONTROL_IDS, "direction", "touch", "embed"];
+/** The objects of a configuration or a preset whose keys are known too, by the key that holds them. */
+const NESTED_KEYS = {
+    build: Object.keys(BUILD_KEYS),
+    appBuild: Object.keys(APP_BUILD_KEYS),
+    shell: Object.keys(SHELL_KEYS),
+    a11y: Object.keys(A11Y_KEYS),
+    backgrounds: Object.keys(BACKGROUND_KEYS),
+    widthRange: Object.keys(WIDTH_RANGE_KEYS),
+    controls: TURNED_OFF_CONTROLS
+};
+/**
+ * What to say of the keys of an object that are none of the known ones.
+ *
+ * @param value - the object.
+ * @param known - its keys.
+ * @param prefix - where it is, written before a key's name (`build.`); empty at the top.
+ */
+const unknownKeys = (value, known, prefix) => Object.keys(value)
+    .filter((key) => !known.includes(key))
+    .map((key) => {
+    const named = didYouMean(key, known).trim();
+    return `it has no key "${prefix}${key}". ${named === "" ? `It takes ${known.join(", ")}.` : named}`;
+});
+/** Whether a value is an object that is not a list. */
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * What to say of the keys of each composed catalogue, which `refs` holds by id.
+ *
+ * @param refs - the configuration's `refs`.
+ */
+const refsKeysProblems = (refs) => isObject(refs)
+    ? Object.entries(refs).flatMap(([id, ref]) => isObject(ref) ? unknownKeys(ref, Object.keys(REF_KEYS), `refs.${id}.`) : [])
+    : [];
+/**
+ * What to say of the keys of a configuration or a preset, one level down included.
+ *
+ * @param value - the object.
+ * @param known - its keys.
+ */
+const keysProblems = (value, known) => [
+    ...unknownKeys(value, known, ""),
+    ...Object.entries(NESTED_KEYS).flatMap(([key, keys]) => {
+        const nested = Reflect.get(value, key);
+        return isObject(nested) ? unknownKeys(nested, keys, `${key}.`) : [];
+    }),
+    ...refsKeysProblems(Reflect.get(value, "refs"))
+];
+/**
+ * Why a loaded configuration holds a key no version of it reads, its presets' included, or none: every such key, so that
+ * one run shows them all.
+ *
+ * @param config - what the file exports by default.
+ */
+export const unknownKeysProblem = (config) => {
+    const presets = Reflect.get(config, "presets");
+    const problems = [
+        ...keysProblems(config, Object.keys(CONFIG_KEYS)),
+        ...(Array.isArray(presets) ? presets : []).flatMap((preset) => {
+            if (typeof preset !== "object" || preset === null)
+                return [];
+            const name = Reflect.get(preset, "name");
+            return keysProblems(preset, Object.keys(PRESET_KEYS)).map((problem) => `its preset "${String(name)}": ${problem}`);
+        })
+    ];
+    return problems.length === 0 ? undefined : problems.join(" ");
+};
+/**
+ * Whether a configuration says it has no design system (`tokens: []`), which leaving the key out does not.
+ *
+ * @param config - the configuration.
+ */
+export const saysNoTokens = ({ tokens }) => tokens?.length === 0;

package/dist/src/vite/configLoadError.d.ts

@@ -0,0 +1,23 @@
+/** Where a syntax error is. */
+type ErrorPlace = {
+    /** The file, by absolute path. */
+    readonly file: string;
+    /** Its line, from 1. */
+    readonly line: number;
+    /** Its column, from 1. */
+    readonly column: number;
+};
+/**
+ * Where Node's stack says a syntax error is, when it says.
+ *
+ * @param stack - the error's stack.
+ */
+export declare const placeInStack: (stack: string) => ErrorPlace | undefined;
+/**
+ * The message for a configuration file that did not load.
+ *
+ * @param file - the configuration file, by absolute path.
+ * @param error - what its import threw.
+ */
+export declare const configLoadMessage: (file: string, error: unknown) => Promise<string>;
+export {};

package/dist/src/vite/configLoadError.js

@@ -0,0 +1,71 @@
+/**
+ * What to say when a configuration file does not load: the file, and for a syntax error its line and column, in the form
+ * editors and terminals open (`/path/forgebook.config.ts:3:3: …`).
+ *
+ * @remarks
+ * Node names the place of a syntax error in TypeScript in the error's stack: the file and line, then the source with
+ * carets under the mistake, for whichever file was at fault, which may be one the configuration imports. For JavaScript
+ * it says nothing (the place is printed only when the process dies of it), so the file is read again with the TypeScript
+ * parser, loaded only here since a configuration that loads never needs it. That finds a mistake in the configuration
+ * itself; one in a JavaScript file it imports keeps Node's message under the configuration's name.
+ *
+ * @module
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/** The first line of a stack Node decorated with the source: the file, by address or by path, and the line. */
+const STACK_HEAD = /^(file:\/\/.+|\/.+|[A-Za-z]:\\.+):(\d+)$/;
+/** The line under the source that points at the mistake. */
+const CARETS = /^(\s*)\^+\s*$/;
+/**
+ * Where Node's stack says a syntax error is, when it says.
+ *
+ * @param stack - the error's stack.
+ */
+export const placeInStack = (stack) => {
+    const lines = stack.split("\n");
+    const head = STACK_HEAD.exec(lines[0] ?? "");
+    const named = head?.[1];
+    const line = head?.[2];
+    if (named === undefined || line === undefined)
+        return undefined;
+    const carets = lines.map((each) => CARETS.exec(each)).find((match) => match !== null);
+    return {
+        file: named.startsWith("file://") ? fileURLToPath(named) : named,
+        line: Number(line),
+        column: (carets?.[1]?.length ?? 0) + 1
+    };
+};
+/**
+ * Where the TypeScript parser finds the first syntax error of a file, when it finds one.
+ *
+ * @param file - the file, by absolute path.
+ */
+const placeInFile = async (file) => {
+    const { default: ts } = await import("typescript-6");
+    const { diagnostics = [] } = ts.transpileModule(readFileSync(file, "utf8"), {
+        fileName: file,
+        reportDiagnostics: true,
+        compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext }
+    });
+    const first = diagnostics.find((each) => each.file !== undefined && each.start !== undefined);
+    if (first?.file === undefined || first.start === undefined)
+        return undefined;
+    const { line, character } = first.file.getLineAndCharacterOfPosition(first.start);
+    return { file, line: line + 1, column: character + 1 };
+};
+/**
+ * The message for a configuration file that did not load.
+ *
+ * @param file - the configuration file, by absolute path.
+ * @param error - what its import threw.
+ */
+export const configLoadMessage = async (file, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!(error instanceof SyntaxError))
+        return `${file}: it did not load: ${message}`;
+    const place = placeInStack(error.stack ?? "") ?? (await placeInFile(file).catch(() => undefined));
+    return place === undefined
+        ? `${file}: ${message}`
+        : `${place.file}:${place.line}:${place.column}: ${message}`;
+};

package/dist/src/vite/cssDeclarations.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The custom properties a style sheet declares, with where each stands, and the statements that lead to other sheets.
+ *
+ * @remarks
+ * Pure, and a scanner of its own rather than a CSS parser: the sheets that hold a project's system are as often Sass or
+ * Less as CSS, and they hold at-rules a CSS parser refuses (`@theme`, `@apply`, `@mixin`). All this needs is the nesting
+ * and the declarations, which every one of those languages writes alike. A value is kept as written: what it comes to
+ * depends on every other sheet, so `cssTokenValues.ts` works it out once all are read.
+ *
+ * @module
+ */
+/** Where a declaration stands, as far as a design system goes. */
+export type CssPlace = 
+/** On the document (`:root`, `html`, `:host`), so anything can read it. */
+{
+    readonly kind: "root";
+}
+/** In Tailwind's `@theme`, which makes utilities of it. */
+ | {
+    readonly kind: "theme";
+}
+/** Applied by a theme (`.dark`, `[data-theme="x"]`, a colour-scheme query). */
+ | {
+    readonly kind: "mode";
+    readonly mode: string;
+}
+/**
+ * On one selector, which may be a component's own variables or a system's root: how many it holds tells. A theme may
+ * apply over it (`.app.dark`, `.app { &.dark { … } }`).
+ */
+ | {
+    readonly kind: "selector";
+    readonly selector: string;
+    readonly mode?: string;
+}
+/** Inside something that applies only sometimes (a width query, an animation): not a token's value. */
+ | {
+    readonly kind: "conditional";
+};
+/** A custom property a sheet declares. */
+export type CssDeclaration = {
+    /** Its name, with its dashes. */
+    readonly name: string;
+    /** Its value, as written. */
+    readonly value: string;
+    /** Its line, from 1. */
+    readonly line: number;
+    /** Where it stands. */
+    readonly place: CssPlace;
+};
+/** What a sheet holds. */
+export type CssReading = {
+    /** Its custom properties, in order. */
+    readonly declarations: readonly CssDeclaration[];
+    /** What its `@import`s name, as written. */
+    readonly imports: readonly string[];
+    /** What its `@config`s name, as written: Tailwind's configuration files. */
+    readonly configs: readonly string[];
+    /** What its `@plugin`s name: their tokens cannot be known without running them. */
+    readonly plugins: readonly string[];
+    /** Whether it brings in Tailwind's default theme. */
+    readonly importsTailwindTheme: boolean;
+    /** Whether it uses Tailwind's older directives, which mean a configuration file and not `@theme`. */
+    readonly usesTailwindDirectives: boolean;
+};
+/**
+ * Reads a sheet.
+ *
+ * @param text - the sheet's text: CSS, Sass or Less.
+ */
+export declare const readCssText: (text: string) => CssReading;

package/dist/src/vite/cssDeclarations.js

@@ -0,0 +1,290 @@
+/**
+ * The custom properties a style sheet declares, with where each stands, and the statements that lead to other sheets.
+ *
+ * @remarks
+ * Pure, and a scanner of its own rather than a CSS parser: the sheets that hold a project's system are as often Sass or
+ * Less as CSS, and they hold at-rules a CSS parser refuses (`@theme`, `@apply`, `@mixin`). All this needs is the nesting
+ * and the declarations, which every one of those languages writes alike. A value is kept as written: what it comes to
+ * depends on every other sheet, so `cssTokenValues.ts` works it out once all are read.
+ *
+ * @module
+ */
+/** A class or an attribute's value that names the dark or the light theme, not one that only ends like it (`btn-light`). */
+const MODE_NAME = /^(?:[\w-]*(?:theme|mode)[-_]+)?(dark|light)(?:[-_]+(?:mode|theme))?$/i;
+/** A theme named in a class or an attribute. */
+const NAMED_THEME = /(?:\.theme[-_]+|\[data-(?:theme|mode|color-mode|color-scheme)[~|^$*]?=["']?)([\w-]+)/i;
+/** A class or an attribute in a selector. */
+const SIMPLE_SELECTOR = /\.[\w-]+|\[[^\]]+\]/g;
+/** The way a theme goes without a class. */
+const COLOR_SCHEME_QUERY = /prefers-color-scheme:\s*(dark|light)/i;
+/** A `@variant` naming a theme, inside a selector or `@theme`. */
+const VARIANT_RULE = /^@variant\s+(dark|light)\b/i;
+/** At-rules whose contents hold in every case. */
+const TRANSPARENT_RULE = /^@(?:layer|supports|container\s+style)\b/;
+/** What Tailwind's `@import` names. */
+const TAILWIND_THEME_IMPORT = /^(?:tailwindcss|tailwindcss\/theme(?:\.css)?)$/;
+/** The older directives. */
+const TAILWIND_DIRECTIVE = /^@tailwind\s+(?:base|components|utilities)\b/;
+/** A quoted or `url()` path after an at-rule's name. */
+const QUOTED_PATH = /^@[\w-]+\s+(?:\([^)]*\)\s*)?(?:url\(\s*)?["']?([^"')\s;,]+)/;
+/** A selector list's parts, not splitting inside parentheses or brackets. */
+const selectorParts = (selector) => {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const character of selector) {
+        if (character === "(" || character === "[")
+            depth += 1;
+        if (character === ")" || character === "]")
+            depth -= 1;
+        if (character === "," && depth === 0) {
+            parts.push(current.trim());
+            current = "";
+        }
+        else
+            current += character;
+    }
+    parts.push(current.trim());
+    return parts.filter((part) => part !== "");
+};
+/** A selector with `:is()` and `:where()` taken off and what stands for the document or the parent dropped. */
+const plainPart = (part) => part
+    .replace(/:(?:is|where)\(([^()]*)\)/g, "$1")
+    .replace(/^(?:&|:root|html|body|:host)(?=[.[:]|$)/, "")
+    .trim();
+/** The theme a `:not()` means: the opposite of the one it leaves out. */
+const modeOfNot = (part) => {
+    const left = /:not\(([^()]*)\)/.exec(part)?.[1];
+    const word = left === undefined ? undefined : MODE_NAME.exec(left.replace(/^[.[]/, ""))?.[1]?.toLowerCase();
+    if (word === undefined)
+        return undefined;
+    return word === "dark" ? "light" : "dark";
+};
+/** The theme a class or an attribute names. */
+const modeOfName = (name) => (MODE_NAME.exec(name)?.[1] ?? NAMED_THEME.exec(`.${name}`)?.[1])?.toLowerCase();
+/** What one selector says: `.dark .card` is that card's variables in a theme, so a descendant names no theme. */
+const partMeaning = (written) => {
+    const part = plainPart(written);
+    if (part === "")
+        return { isRoot: true };
+    if (/\s|>|~|\+/.test(part))
+        return { selector: written };
+    const not = modeOfNot(part);
+    if (not !== undefined)
+        return { mode: not };
+    const simple = [...part.matchAll(SIMPLE_SELECTOR)].map((match) => match[0]);
+    const named = simple.map((each) => {
+        const attribute = NAMED_THEME.exec(each)?.[1] ?? /=["']?([\w-]+)/.exec(each)?.[1];
+        return attribute === undefined ? modeOfName(each.slice(1)) : attribute.toLowerCase();
+    });
+    const mode = named.find((each) => each !== undefined);
+    if (mode === undefined)
+        return { selector: written };
+    const others = simple.filter((_, index) => named[index] === undefined);
+    return others.length === 0 ? { mode } : { mode, selector: others.join("") };
+};
+/** What one block says, from its text. */
+const meaningOf = (block) => {
+    const themed = COLOR_SCHEME_QUERY.exec(block)?.[1] ?? VARIANT_RULE.exec(block)?.[1];
+    if (themed !== undefined)
+        return { mode: themed.toLowerCase() };
+    if (block.startsWith("@theme"))
+        return { isTheme: true };
+    if (TRANSPARENT_RULE.test(block))
+        return {};
+    if (block.startsWith("@"))
+        return { isConditional: true };
+    const parts = selectorParts(block).map(partMeaning);
+    // `:root, .light` is the base written out, which a theme overrides
+    if (parts.some((part) => part.isRoot === true))
+        return {};
+    const mode = parts.find((part) => part.mode !== undefined)?.mode;
+    const selector = parts.some((part) => part.mode === undefined) ? block : parts[0]?.selector;
+    return { ...(mode === undefined ? {} : { mode }), ...(selector === undefined ? {} : { selector }) };
+};
+/** Where a declaration stands, under what the blocks it is inside mean, outermost first. */
+const placeOf = (meanings) => {
+    if (meanings.some((each) => each.isConditional === true))
+        return { kind: "conditional" };
+    const mode = meanings.findLast((each) => each.mode !== undefined)?.mode;
+    const selector = meanings.find((each) => each.selector !== undefined)?.selector;
+    if (selector !== undefined) {
+        return { kind: "selector", selector, ...(mode === undefined ? {} : { mode }) };
+    }
+    if (mode !== undefined)
+        return { kind: "mode", mode };
+    return meanings.some((each) => each.isTheme === true) ? { kind: "theme" } : { kind: "root" };
+};
+/** Where a quote's text ends, past its closing quote. */
+const afterString = (text, start) => {
+    const quote = text[start];
+    for (let index = start + 1; index < text.length; index += 1) {
+        if (text[index] === "\\")
+            index += 1;
+        else if (text[index] === quote || text[index] === "\n")
+            return index + 1;
+    }
+    return text.length;
+};
+/** Where a brace opened at a position closes, past it. */
+const afterBlock = (text, start) => {
+    let depth = 0;
+    for (let index = start; index < text.length; index += 1) {
+        if (text[index] === "{")
+            depth += 1;
+        if (text[index] === "}")
+            depth -= 1;
+        if (depth === 0)
+            return index + 1;
+    }
+    return text.length;
+};
+/** Where a comment starting at a position ends, or the position when none starts there. */
+const afterComment = (text, index) => {
+    if (text.startsWith("/*", index)) {
+        const end = text.indexOf("*/", index + 2);
+        return end === -1 ? text.length : end + 2;
+    }
+    // a line comment in Sass and Less, also inside a map's parentheses; after a colon or `url(` it is an address
+    const isLineComment = text.startsWith("//", index) && text[index - 1] !== ":" && text[index - 1] !== "(";
+    return isLineComment ? text.indexOf("\n", index) + 1 || text.length : index;
+};
+/** How far into parentheses a character leaves a run of text. */
+const parenthesesAfter = (character, depth) => {
+    if (character === "(")
+        return depth + 1;
+    return character === ")" ? Math.max(0, depth - 1) : depth;
+};
+/** A sheet with its comments blanked and every newline kept, so an offset still gives a line. */
+const withoutComments = (text) => {
+    let out = "";
+    let index = 0;
+    while (index < text.length) {
+        const end = afterComment(text, index);
+        if (end !== index) {
+            out += text.slice(index, end).replace(/[^\n]/g, " ");
+            index = end;
+        }
+        else if (text[index] === '"' || text[index] === "'") {
+            const close = afterString(text, index);
+            out += text.slice(index, close);
+            index = close;
+        }
+        else {
+            out += text[index];
+            index += 1;
+        }
+    }
+    return out;
+};
+/** Where a run of text a brace must not end (a string, Sass's `#{…}`, a custom property's block) ends, or the start. */
+const afterOpaque = (text, index, statement) => {
+    const character = text[index];
+    if (character === '"' || character === "'")
+        return afterString(text, index);
+    if (character === "#" && text[index + 1] === "{")
+        return afterBlock(text, index + 1);
+    return character === "{" && statement.trimStart().startsWith("--") ? afterBlock(text, index) : index;
+};
+/** A sheet with no comments as its blocks and statements. */
+const sheetParts = (text) => {
+    const parts = [];
+    let statement = "";
+    let start = 0;
+    let depth = 0;
+    const finish = () => {
+        if (statement.trim() !== "")
+            parts.push({ kind: "statement", text: statement.trim(), start });
+        statement = "";
+    };
+    const structure = (character) => {
+        if (character === "{") {
+            parts.push({ kind: "open", prelude: statement.trim().replace(/\s+/g, " ") });
+            statement = "";
+            return;
+        }
+        finish();
+        if (character === "}")
+            parts.push({ kind: "close" });
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index] ?? "";
+        const end = afterOpaque(text, index, statement);
+        if (statement === "")
+            start = index;
+        if (end !== index) {
+            statement += text.slice(index, end);
+            index = end - 1;
+        }
+        else if (depth === 0 && "{};".includes(character)) {
+            structure(character);
+        }
+        else {
+            depth = parenthesesAfter(character, depth);
+            // what comes before a statement is not part of it, and its first character gives its line
+            if (statement !== "" || !/\s/.test(character))
+                statement += character;
+        }
+    }
+    finish();
+    return parts;
+};
+/** The value of a declaration, with no `!important` and its spacing made plain. */
+const declaredValue = (written) => {
+    const text = written.trim();
+    const flag = "!important";
+    const plain = text.endsWith(flag) ? text.slice(0, -flag.length) : text;
+    return plain.split(/\s+/).join(" ").trim();
+};
+/** The path an at-rule of a name holds, when the statement is that rule. */
+const pathOfRule = (written, rule) => {
+    if (!written.startsWith(rule))
+        return [];
+    const path = QUOTED_PATH.exec(written)?.[1];
+    return path === undefined ? [] : [path];
+};
+/**
+ * Reads a sheet.
+ *
+ * @param text - the sheet's text: CSS, Sass or Less.
+ */
+export const readCssText = (text) => {
+    const plain = withoutComments(text);
+    const meanings = [];
+    const statements = [];
+    const declarations = [];
+    let counted = 0;
+    let line = 1;
+    const lineAt = (offset) => {
+        for (; counted < offset; counted += 1)
+            if (plain[counted] === "\n")
+                line += 1;
+        return line;
+    };
+    for (const part of sheetParts(plain)) {
+        if (part.kind === "open")
+            meanings.push(meaningOf(part.prelude));
+        else if (part.kind === "close")
+            meanings.pop();
+        else if (part.text.startsWith("--") && part.text.indexOf(":") > 0) {
+            const colon = part.text.indexOf(":");
+            declarations.push({
+                name: part.text.slice(0, colon).trim(),
+                value: declaredValue(part.text.slice(colon + 1)),
+                line: lineAt(part.start),
+                place: placeOf(meanings)
+            });
+        }
+        else
+            statements.push(part.text);
+    }
+    const imports = statements.flatMap((each) => ["@import", "@use", "@forward"].flatMap((rule) => pathOfRule(each, rule)));
+    return {
+        declarations,
+        imports,
+        configs: statements.flatMap((each) => pathOfRule(each, "@config")),
+        plugins: statements.flatMap((each) => pathOfRule(each, "@plugin")),
+        importsTailwindTheme: imports.some((path) => TAILWIND_THEME_IMPORT.test(path)),
+        usesTailwindDirectives: statements.some((each) => TAILWIND_DIRECTIVE.test(each))
+    };
+};

package/dist/src/vite/cssImports.d.ts

@@ -0,0 +1,14 @@
+/** What a sheet came to. */
+export type InlinedCss = {
+    /** The text. */
+    readonly css: string;
+    /** The files written in, absolute. */
+    readonly files: readonly string[];
+};
+/**
+ * A sheet with its relative imports written in.
+ *
+ * @param css - its text.
+ * @param file - its file, absolute.
+ */
+export declare const inlineCssImports: (css: string, file: string) => InlinedCss;