@marianmeres/stuic 3.190.0 → 3.192.0

package/dist/components/CodeBlock/highlight/index.js

@@ -0,0 +1,29 @@
+import { highlightJson } from "./json.js";
+import { highlightHttp } from "./http.js";
+import { highlightShell } from "./shell.js";
+export { highlightJson, highlightHttp, highlightShell };
+const BY_LANG = {
+    json: highlightJson,
+    jsonc: highlightJson,
+    json5: highlightJson,
+    http: highlightHttp,
+    bash: highlightShell,
+    sh: highlightShell,
+    shell: highlightShell,
+    zsh: highlightShell,
+    console: highlightShell,
+    terminal: highlightShell,
+    "shell-session": highlightShell,
+    shellsession: highlightShell,
+};
+/** The `lang`s `highlightCode` knows (lower case). */
+export const HIGHLIGHT_CODE_LANGS = Object.keys(BY_LANG);
+/**
+ * `CodeBlock`'s built-in highlighter: JSON, HTTP and shell, picked by `lang` (case
+ * insensitive — see `HIGHLIGHT_CODE_LANGS`). Any other `lang` gets no tokens. Compose it
+ * to add a language: `(code, lang) => lang === "ts" ? myTs(code) : highlightCode(code, lang)`.
+ */
+export const highlightCode = (code, lang) => {
+    const fn = lang ? BY_LANG[lang.trim().toLowerCase()] : undefined;
+    return fn ? fn(code) : [];
+};

package/dist/components/CodeBlock/highlight/json.d.ts

@@ -0,0 +1,9 @@
+import type { CodeBlockToken } from "./types.js";
+/**
+ * Tokenizes JSON into `out`, offsetting every token by `base` (so an HTTP body can be
+ * tokenized in place). Tolerant: `//` and `/* *\/` comments, unterminated strings and
+ * non-JSON placeholders (`...`) never throw — unknown characters are simply skipped.
+ */
+export declare function tokenizeJsonInto(code: string, base: number, out: CodeBlockToken[]): void;
+/** Highlights JSON (and JSON with comments): keys, strings, numbers, literals, punctuation. */
+export declare function highlightJson(code: string): CodeBlockToken[];

package/dist/components/CodeBlock/highlight/json.js

@@ -0,0 +1,74 @@
+const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+const LITERAL = /(?:true|false|null)(?![\w$])/y;
+const WORD_CHAR = /[\w$.]/;
+/**
+ * Tokenizes JSON into `out`, offsetting every token by `base` (so an HTTP body can be
+ * tokenized in place). Tolerant: `//` and `/* *\/` comments, unterminated strings and
+ * non-JSON placeholders (`...`) never throw — unknown characters are simply skipped.
+ */
+export function tokenizeJsonInto(code, base, out) {
+    const n = code.length;
+    let i = 0;
+    while (i < n) {
+        const c = code[i];
+        if (c === '"') {
+            let j = i + 1;
+            while (j < n && code[j] !== '"' && code[j] !== "\n")
+                j += code[j] === "\\" ? 2 : 1;
+            const end = Math.min(code[j] === '"' ? j + 1 : j, n);
+            // a key is a string followed by a colon
+            let k = end;
+            while (code[k] === " " || code[k] === "\t")
+                k++;
+            out.push([base + i, base + end, code[k] === ":" ? "property" : "string"]);
+            i = end;
+            continue;
+        }
+        if (c === "/" && code[i + 1] === "/") {
+            const nl = code.indexOf("\n", i);
+            const end = nl < 0 ? n : nl;
+            out.push([base + i, base + end, "comment"]);
+            i = end;
+            continue;
+        }
+        if (c === "/" && code[i + 1] === "*") {
+            const close = code.indexOf("*/", i + 2);
+            const end = close < 0 ? n : close + 2;
+            out.push([base + i, base + end, "comment"]);
+            i = end;
+            continue;
+        }
+        if ("{}[],:".includes(c)) {
+            out.push([base + i, base + i + 1, "punctuation"]);
+            i++;
+            continue;
+        }
+        if (!WORD_CHAR.test(code[i - 1] ?? "")) {
+            if (c === "-" || (c >= "0" && c <= "9")) {
+                NUMBER.lastIndex = i;
+                const m = NUMBER.exec(code);
+                if (m && m[0] !== "-") {
+                    out.push([base + i, base + i + m[0].length, "number"]);
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            if (c === "t" || c === "f" || c === "n") {
+                LITERAL.lastIndex = i;
+                const m = LITERAL.exec(code);
+                if (m) {
+                    out.push([base + i, base + i + m[0].length, "literal"]);
+                    i += m[0].length;
+                    continue;
+                }
+            }
+        }
+        i++;
+    }
+}
+/** Highlights JSON (and JSON with comments): keys, strings, numbers, literals, punctuation. */
+export function highlightJson(code) {
+    const out = [];
+    tokenizeJsonInto(code, 0, out);
+    return out;
+}

package/dist/components/CodeBlock/highlight/shell.d.ts

@@ -0,0 +1,8 @@
+import type { CodeBlockToken } from "./types.js";
+/**
+ * Highlights a shell command or session (bash, sh, zsh): `$ ` prompts, comments, quoted
+ * strings with the variables inside them, `$VARS`/`${…}`/`$(…)`, the command name, flags,
+ * assignments, operators and `\` line continuations. A reading aid, not a parser —
+ * heredocs and backticks are left plain.
+ */
+export declare function highlightShell(code: string): CodeBlockToken[];

package/dist/components/CodeBlock/highlight/shell.js

@@ -0,0 +1,230 @@
+const KEYWORDS = new Set([
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "until",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "in",
+    "function",
+    "select",
+    "return",
+    "export",
+    "local",
+    "readonly",
+    "declare",
+    "unset",
+]);
+/** Keywords followed by a name or a word list, not by a command */
+const NOT_FOLLOWED_BY_COMMAND = new Set(["for", "select", "case", "in", "function"]);
+/** Keywords followed by assignments */
+const DECLARING = new Set(["export", "local", "readonly", "declare"]);
+const ASSIGNMENT = /^[A-Za-z_]\w*=/;
+/** Characters that end an unquoted word */
+const WORD_END = /[\s|&;<>()'"$`]/;
+/**
+ * Highlights a shell command or session (bash, sh, zsh): `$ ` prompts, comments, quoted
+ * strings with the variables inside them, `$VARS`/`${…}`/`$(…)`, the command name, flags,
+ * assignments, operators and `\` line continuations. A reading aid, not a parser —
+ * heredocs and backticks are left plain.
+ */
+export function highlightShell(code) {
+    const out = [];
+    const n = code.length;
+    const push = (start, end, type) => {
+        if (end > start)
+            out.push([start, end, type]);
+    };
+    /** End of the `$…` expansion starting at `i` (a `$` followed by an expandable char) */
+    const expansionEnd = (i) => {
+        const next = code[i + 1];
+        if (next === "{" || next === "(") {
+            const close = next === "{" ? "}" : ")";
+            let depth = 0;
+            for (let j = i + 1; j < n; j++) {
+                if (code[j] === next)
+                    depth++;
+                else if (code[j] === close && --depth === 0)
+                    return j + 1;
+            }
+            return n;
+        }
+        if (/[A-Za-z_]/.test(next)) {
+            let j = i + 2;
+            while (j < n && /\w/.test(code[j]))
+                j++;
+            return j;
+        }
+        return i + 2; // $1 $? $@ $# $* $! $$ $-
+    };
+    const isExpansion = (i) => /[A-Za-z_{(0-9@*#?!$-]/.test(code[i + 1] ?? "");
+    let i = 0;
+    let command = true; // the next word is a command name
+    let declaring = false; // after `export` & co. — words are assignments
+    let awaitingIn = 0; // `for NAME in`, `case WORD in`: words until the `in`
+    let lineStart = true;
+    while (i < n) {
+        const c = code[i];
+        if (c === "\n") {
+            i++;
+            command = true;
+            declaring = false;
+            awaitingIn = 0;
+            lineStart = true;
+            continue;
+        }
+        if (c === " " || c === "\t") {
+            i++;
+            continue;
+        }
+        // a `$ ` prompt (a `$` followed by a space can't be an expansion)
+        if (lineStart) {
+            lineStart = false;
+            if (c === "$" && (i + 1 === n || code[i + 1] === " " || code[i + 1] === "\n")) {
+                push(i, i + 1, "meta");
+                i++;
+                continue;
+            }
+        }
+        // `\` + newline: the command continues on the next line
+        if (c === "\\" && code[i + 1] === "\n") {
+            push(i, i + 1, "punctuation");
+            i += 2;
+            continue;
+        }
+        // only at the start of a word — mid-word `#` (a URL fragment) is part of the word
+        if (c === "#") {
+            const nl = code.indexOf("\n", i);
+            const end = nl < 0 ? n : nl;
+            push(i, end, "comment");
+            i = end;
+            continue;
+        }
+        if (c === "'") {
+            const close = code.indexOf("'", i + 1);
+            const end = close < 0 ? n : close + 1;
+            push(i, end, "string");
+            i = end;
+            command = false;
+            continue;
+        }
+        if (c === '"') {
+            let from = i;
+            let j = i + 1;
+            while (j < n && code[j] !== '"') {
+                if (code[j] === "\\") {
+                    j += 2;
+                }
+                else if (code[j] === "$" && isExpansion(j)) {
+                    push(from, j, "string");
+                    const e = expansionEnd(j);
+                    push(j, e, "variable");
+                    from = j = e;
+                }
+                else {
+                    j++;
+                }
+            }
+            const end = Math.min(j + 1, n);
+            push(from, end, "string");
+            i = end;
+            command = false;
+            continue;
+        }
+        if (c === "$" && isExpansion(i)) {
+            if (code[i + 1] === "(") {
+                // command substitution: a nested command line
+                push(i, i + 2, "punctuation");
+                i += 2;
+                command = true;
+                continue;
+            }
+            const e = expansionEnd(i);
+            push(i, e, "variable");
+            i = e;
+            command = false;
+            continue;
+        }
+        if (c === "|" || c === "&" || c === ";") {
+            const two = code.slice(i, i + 2);
+            const len = two === "||" || two === "&&" || two === ";;" ? 2 : 1;
+            push(i, i + len, "operator");
+            i += len;
+            command = true;
+            declaring = false;
+            continue;
+        }
+        if (c === ">" || c === "<") {
+            const len = code[i + 1] === c || code[i + 1] === "&" ? 2 : 1;
+            push(i, i + len, "operator");
+            i += len;
+            continue;
+        }
+        if (c === "(" || c === ")" || c === "{" || c === "}") {
+            push(i, i + 1, "punctuation");
+            i++;
+            if (c === "(" || c === "{")
+                command = true;
+            continue;
+        }
+        // an unquoted word
+        let j = i;
+        while (j < n && !WORD_END.test(code[j])) {
+            if (code[j] === "\\") {
+                if (code[j + 1] === "\n")
+                    break; // a continuation, tokenized on the next round
+                j += 2;
+            }
+            else {
+                j++;
+            }
+        }
+        if (j === i) {
+            // a lone character the rules above don't claim (a stray backslash, a backtick)
+            i++;
+            continue;
+        }
+        const word = code.slice(i, Math.min(j, n));
+        const inKeyword = awaitingIn === 1 && word === "in";
+        if (awaitingIn)
+            awaitingIn--;
+        const assignment = (command || declaring) && ASSIGNMENT.exec(word);
+        if (inKeyword) {
+            push(i, j, "keyword");
+        }
+        else if (assignment) {
+            const eq = i + assignment[0].length - 1;
+            push(i, eq, "variable");
+            push(eq, eq + 1, "operator");
+            // `FOO=1 cmd`: the command still follows
+        }
+        else if (command) {
+            if (KEYWORDS.has(word)) {
+                push(i, j, "keyword");
+                command = !NOT_FOLLOWED_BY_COMMAND.has(word) && !DECLARING.has(word);
+                declaring = DECLARING.has(word);
+                if (word === "for" || word === "select" || word === "case")
+                    awaitingIn = 2;
+            }
+            else {
+                push(i, j, "function");
+                command = false;
+            }
+        }
+        else if (word.length > 1 && word[0] === "-" && !/^-\d/.test(word)) {
+            const eq = word.indexOf("=");
+            push(i, eq < 0 ? j : i + eq, "parameter");
+        }
+        else if (/^\d+$/.test(word)) {
+            push(i, j, "number");
+        }
+        i = j;
+    }
+    return out;
+}

package/dist/components/CodeBlock/highlight/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The token types the built-in highlighters emit, and the ones `CodeBlock`'s stylesheet
+ * colors (all but `punctuation`, which is emitted but left in the text color).
+ */
+export type CodeBlockTokenType = "comment" | "string" | "number" | "literal" | "keyword" | "property" | "variable" | "function" | "parameter" | "operator" | "punctuation" | "meta";
+/**
+ * One highlighted span: `[start, end)` offsets into the code as displayed (after
+ * normalization), and its type. A custom type is allowed — it is painted by
+ * `::highlight(stuic-code-block-<type>)`, which the consumer styles.
+ */
+export type CodeBlockToken = [
+    start: number,
+    end: number,
+    type: CodeBlockTokenType | (string & {})
+];
+/** Turns a sample into tokens. `lang` is whatever the block was given. */
+export type CodeBlockHighlighter = (code: string, lang?: string) => CodeBlockToken[];

package/dist/components/CodeBlock/highlight/types.js

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

package/dist/components/CodeBlock/i18n-sk.d.ts

@@ -0,0 +1,17 @@
+import type { CodeBlockMessages } from "./i18n.js";
+/**
+ * Slovak message catalog for `CodeBlock` (its copy button included). Opt-in — English
+ * stays the built-in default, and this module is only pulled into a bundle when it is
+ * actually imported.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { CodeBlock, createCodeBlockT, CODE_BLOCK_MESSAGES_SK } from "@marianmeres/stuic";
+ *   const t = createCodeBlockT(CODE_BLOCK_MESSAGES_SK);
+ * </script>
+ *
+ * <CodeBlock lang="bash" code={sample} {t} />
+ * ```
+ */
+export declare const CODE_BLOCK_MESSAGES_SK: CodeBlockMessages;

package/dist/components/CodeBlock/i18n-sk.js

@@ -0,0 +1,22 @@
+import { COPY_BUTTON_MESSAGES_SK } from "../CopyButton/i18n-sk.js";
+/**
+ * Slovak message catalog for `CodeBlock` (its copy button included). Opt-in — English
+ * stays the built-in default, and this module is only pulled into a bundle when it is
+ * actually imported.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { CodeBlock, createCodeBlockT, CODE_BLOCK_MESSAGES_SK } from "@marianmeres/stuic";
+ *   const t = createCodeBlockT(CODE_BLOCK_MESSAGES_SK);
+ * </script>
+ *
+ * <CodeBlock lang="bash" code={sample} {t} />
+ * ```
+ */
+export const CODE_BLOCK_MESSAGES_SK = {
+    ...COPY_BUTTON_MESSAGES_SK,
+    // "všetky riadky" reads right for any count; the number stays out of the plural
+    show_all_lines: "Zobraziť všetky riadky ({count})",
+    show_less: "Zobraziť menej",
+};

package/dist/components/CodeBlock/i18n.d.ts

@@ -0,0 +1,37 @@
+import type { TranslateFn } from "../../types.js";
+/**
+ * The built-in (English) message catalog of `CodeBlock`. It includes the `CopyButton`
+ * keys, so the one `t` a block is given also localizes its copy button. Also the fallback
+ * of every other bundled locale, so a locale missing a key still renders text.
+ */
+export declare const CODE_BLOCK_MESSAGES_EN: {
+    /** The collapse toggle while collapsed; `{count}` is the sample's line count */
+    show_all_lines: string;
+    /** The collapse toggle while expanded */
+    show_less: string;
+    copy: string;
+    copied: string;
+    copy_failed: string;
+};
+/** Every message key `CodeBlock` may look up. */
+export type CodeBlockMessageKey = keyof typeof CODE_BLOCK_MESSAGES_EN;
+/** A (possibly partial) catalog for one locale. */
+export type CodeBlockMessages = Record<CodeBlockMessageKey, string>;
+/**
+ * Builds the `t` prop of `CodeBlock` from a message catalog. Unknown or untranslated keys
+ * fall back to `fallbackMessages` (English by default); `{name}` placeholders are
+ * replaced from the values.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { CodeBlock, createCodeBlockT, CODE_BLOCK_MESSAGES_SK } from "@marianmeres/stuic";
+ *   const t = createCodeBlockT(CODE_BLOCK_MESSAGES_SK);
+ * </script>
+ *
+ * <CodeBlock lang="bash" code={sample} {t} />
+ * ```
+ */
+export declare function createCodeBlockT(messages: Partial<CodeBlockMessages> | Record<string, string>, fallbackMessages?: Partial<CodeBlockMessages> | Record<string, string>): TranslateFn;
+/** The component's built-in English `t`. */
+export declare const t_default: TranslateFn;

package/dist/components/CodeBlock/i18n.js

@@ -0,0 +1,34 @@
+import { COPY_BUTTON_MESSAGES_EN, createCopyButtonT } from "../CopyButton/i18n.js";
+/**
+ * The built-in (English) message catalog of `CodeBlock`. It includes the `CopyButton`
+ * keys, so the one `t` a block is given also localizes its copy button. Also the fallback
+ * of every other bundled locale, so a locale missing a key still renders text.
+ */
+export const CODE_BLOCK_MESSAGES_EN = {
+    ...COPY_BUTTON_MESSAGES_EN,
+    /** The collapse toggle while collapsed; `{count}` is the sample's line count */
+    show_all_lines: "Show all {count} lines",
+    /** The collapse toggle while expanded */
+    show_less: "Show less",
+};
+/**
+ * Builds the `t` prop of `CodeBlock` from a message catalog. Unknown or untranslated keys
+ * fall back to `fallbackMessages` (English by default); `{name}` placeholders are
+ * replaced from the values.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { CodeBlock, createCodeBlockT, CODE_BLOCK_MESSAGES_SK } from "@marianmeres/stuic";
+ *   const t = createCodeBlockT(CODE_BLOCK_MESSAGES_SK);
+ * </script>
+ *
+ * <CodeBlock lang="bash" code={sample} {t} />
+ * ```
+ */
+export function createCodeBlockT(messages, fallbackMessages = CODE_BLOCK_MESSAGES_EN) {
+    // same lookup + `{placeholder}` semantics as CopyButton's
+    return createCopyButtonT(messages, fallbackMessages);
+}
+/** The component's built-in English `t`. */
+export const t_default = createCodeBlockT(CODE_BLOCK_MESSAGES_EN);