@calliopelabs/ui 0.14.0 → 0.16.0

package/dist/workbench/model.js

@@ -0,0 +1,214 @@
+/**
+ * The file browser's data: plain values the host maps its own listing onto.
+ * Pure (no "use client"), so a server can sort or build fixtures with it.
+ */
+/** The parent directory of a path; the root is "". */
+export function parentPath(path) {
+    const i = path.lastIndexOf("/");
+    return i < 0 ? "" : path.slice(0, i);
+}
+/** A path under a directory; the root is "". */
+export function joinPath(dir, name) {
+    return dir ? `${dir}/${name}` : name;
+}
+/** True when `path` is `ancestor` or lies under it. */
+export function isWithin(path, ancestor) {
+    return ancestor === "" || path === ancestor || path.startsWith(`${ancestor}/`);
+}
+/** The lower-case extension without the dot, or "" (".bashrc" has none). */
+export function fileExtension(name) {
+    const i = name.lastIndexOf(".");
+    return i > 0 ? name.slice(i + 1).toLowerCase() : "";
+}
+/** The breadcrumb trail of a path: the root, then each directory down to it. */
+export function pathSegments(path) {
+    const parts = path.split("/").filter(Boolean);
+    return parts.map((name, i) => ({ name, path: parts.slice(0, i + 1).join("/") }));
+}
+/**
+ * Whether moving `sources` into `target` does anything sensible: never into
+ * itself or its own subtree, and a move into the folder it is already in is
+ * a no-op. Copies (`copy`) may land in the same folder.
+ */
+export function canDrop(sources, target, copy = false) {
+    return (sources.length > 0 &&
+        sources.every((src) => !(target === src || target.startsWith(`${src}/`)) && (copy || parentPath(src) !== target)));
+}
+const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+function time(value) {
+    if (value == null)
+        return null;
+    const t = value instanceof Date ? value.getTime() : Date.parse(value);
+    return Number.isNaN(t) ? null : t;
+}
+/**
+ * A listing in display order: directories first, then by the key, ties and
+ * missing values by name. Natural order, so "file10" follows "file9".
+ */
+export function sortFiles(items, sort) {
+    const sign = sort.dir === "asc" ? 1 : -1;
+    const byName = (a, b) => collator.compare(a.name, b.name);
+    const compare = (a, b) => {
+        switch (sort.key) {
+            case "size": {
+                const x = a.size ?? null;
+                const y = b.size ?? null;
+                if (x === y)
+                    return 0;
+                if (x === null)
+                    return 1;
+                if (y === null)
+                    return -1;
+                return (x - y) * sign;
+            }
+            case "modified": {
+                const x = time(a.modified);
+                const y = time(b.modified);
+                if (x === y)
+                    return 0;
+                if (x === null)
+                    return 1;
+                if (y === null)
+                    return -1;
+                return (x - y) * sign;
+            }
+            case "kind":
+                return collator.compare(fileExtension(a.name), fileExtension(b.name)) * sign;
+            case "name":
+                return byName(a, b) * sign;
+        }
+    };
+    return [...items].sort((a, b) => {
+        if (a.kind !== b.kind)
+            return a.kind === "directory" ? -1 : 1;
+        return compare(a, b) || byName(a, b);
+    });
+}
+/** Bytes for people: 0 B, 912 B, 1.5 KB, 23 MB (1024-based, as file managers show). */
+export function formatBytes(bytes, locale) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return "";
+    const units = ["B", "KB", "MB", "GB", "TB", "PB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    const digits = unit === 0 || value >= 10 ? 0 : 1;
+    return `${value.toLocaleString(locale, { maximumFractionDigits: digits })} ${units[unit]}`;
+}
+const TEXT_EXTENSIONS = new Set([
+    "txt",
+    "log",
+    "py",
+    "js",
+    "jsx",
+    "ts",
+    "tsx",
+    "mjs",
+    "cjs",
+    "rs",
+    "go",
+    "java",
+    "kt",
+    "rb",
+    "sh",
+    "bash",
+    "zsh",
+    "sql",
+    "html",
+    "css",
+    "scss",
+    "xml",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "conf",
+    "env",
+    "r",
+    "c",
+    "h",
+    "cpp",
+    "hpp",
+    "cs",
+    "php",
+    "swift",
+    "lua",
+    "dockerfile",
+    "tf",
+]);
+const IMAGE_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "svg",
+    "webp",
+    "avif",
+    "bmp",
+    "ico",
+]);
+export function previewKindFor(name, mimeType) {
+    const ext = fileExtension(name);
+    if (ext === "csv" || ext === "tsv" || mimeType === "text/csv")
+        return "csv";
+    if (ext === "json" || ext === "jsonl" || ext === "ipynb" || mimeType === "application/json")
+        return "json";
+    if (IMAGE_EXTENSIONS.has(ext) || mimeType?.startsWith("image/"))
+        return "image";
+    if (ext === "md" || ext === "markdown" || mimeType === "text/markdown")
+        return "markdown";
+    if (TEXT_EXTENSIONS.has(ext) || mimeType?.startsWith("text/"))
+        return "text";
+    return "binary";
+}
+/**
+ * Parses CSV (RFC 4180: quoted fields, doubled quotes, newlines inside
+ * quotes) or, with `delimiter: "\t"`, TSV. Returns rows of strings; the
+ * caller decides whether the first row is a header.
+ */
+export function parseDelimited(text, delimiter = ",") {
+    const rows = [];
+    let row = [];
+    let field = "";
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quoted) {
+            if (c === '"') {
+                if (text[i + 1] === '"') {
+                    field += '"';
+                    i++;
+                }
+                else
+                    quoted = false;
+            }
+            else
+                field += c;
+        }
+        else if (c === '"' && field === "")
+            quoted = true;
+        else if (c === delimiter) {
+            row.push(field);
+            field = "";
+        }
+        else if (c === "\n" || c === "\r") {
+            if (c === "\r" && text[i + 1] === "\n")
+                i++;
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = "";
+        }
+        else
+            field += c;
+    }
+    if (field !== "" || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows;
+}

package/dist/workbench/selection.d.ts

@@ -0,0 +1,16 @@
+export type SelectMode = "replace" | "toggle" | "range";
+/**
+ * Finder-style selection over an ordered listing: a plain click or arrow
+ * selects one, Cmd or Ctrl toggles, Shift selects the range from the
+ * anchor (the last item chosen without Shift). The set is the host's.
+ */
+export declare function useSelectionModel(order: readonly string[], selection: ReadonlySet<string>, onSelectionChange: (next: Set<string>) => void): {
+    select(path: string, mode: SelectMode): void;
+    selectAll(): void;
+    clear(): void;
+};
+export declare function modeOf(event: {
+    shiftKey: boolean;
+    metaKey: boolean;
+    ctrlKey: boolean;
+}): SelectMode;

package/dist/workbench/selection.js

@@ -0,0 +1,46 @@
+"use client";
+import * as React from "react";
+/**
+ * Finder-style selection over an ordered listing: a plain click or arrow
+ * selects one, Cmd or Ctrl toggles, Shift selects the range from the
+ * anchor (the last item chosen without Shift). The set is the host's.
+ */
+export function useSelectionModel(order, selection, onSelectionChange) {
+    const anchor = React.useRef(null);
+    return React.useMemo(() => ({
+        select(path, mode) {
+            if (mode === "range") {
+                const from = order.indexOf(anchor.current ?? path);
+                const to = order.indexOf(path);
+                const [a, b] = from < 0 ? [to, to] : from < to ? [from, to] : [to, from];
+                onSelectionChange(new Set(order.slice(a, b + 1)));
+                return;
+            }
+            anchor.current = path;
+            if (mode === "toggle") {
+                const next = new Set(selection);
+                if (next.has(path))
+                    next.delete(path);
+                else
+                    next.add(path);
+                onSelectionChange(next);
+            }
+            else
+                onSelectionChange(new Set([path]));
+        },
+        selectAll() {
+            onSelectionChange(new Set(order));
+        },
+        clear() {
+            anchor.current = null;
+            onSelectionChange(new Set());
+        },
+    }), [order, selection, onSelectionChange]);
+}
+export function modeOf(event) {
+    if (event.shiftKey)
+        return "range";
+    if (event.metaKey || event.ctrlKey)
+        return "toggle";
+    return "replace";
+}

package/dist/workbench/typeahead.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type-to-find for trees, lists and grids: printable keys typed within half
+ * a second build a prefix; the next name after the current one that starts
+ * with it (case-insensitive) is the answer. Returns that index, or null when
+ * the key is not a typeahead key or nothing matches.
+ */
+export declare function typeahead(state: {
+    text: string;
+    at: number;
+}, event: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}, names: readonly string[], current: number): number | null;

package/dist/workbench/typeahead.js

@@ -0,0 +1,22 @@
+/**
+ * Type-to-find for trees, lists and grids: printable keys typed within half
+ * a second build a prefix; the next name after the current one that starts
+ * with it (case-insensitive) is the answer. Returns that index, or null when
+ * the key is not a typeahead key or nothing matches.
+ */
+export function typeahead(state, event, names, current) {
+    if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey || event.key === " ")
+        return null;
+    const now = Date.now();
+    state.text = now - state.at > 500 ? event.key : state.text + event.key;
+    state.at = now;
+    const prefix = state.text.toLowerCase();
+    // A repeated single letter cycles; a longer prefix may stay on the current name.
+    const start = state.text.length === 1 ? current + 1 : current;
+    for (let i = 0; i < names.length; i++) {
+        const index = (start + i) % names.length;
+        if (names[index]?.toLowerCase().startsWith(prefix))
+            return index;
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calliopelabs/ui",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Calliope AI shared operator UI: app shell, navigation, page frame, data table and list patterns, status colours, design tokens and appearance for Astrolift AI and Zentinelle AI.",
   "keywords": [
     "calliope-ai",
@@ -38,6 +38,10 @@
       "types": "./dist/agent/copilotkit/index.d.ts",
       "default": "./dist/agent/copilotkit/index.js"
     },
+    "./workbench": {
+      "types": "./dist/workbench/index.d.ts",
+      "default": "./dist/workbench/index.js"
+    },
     "./theme.css": "./dist/styles/theme.css",
     "./preset.css": "./dist/styles/preset.css",
     "./css/tokens.css": "./dist/css/tokens.css",