@lapismd/design-core 0.1.2 → 0.3.0

package/dist/shared/workspace/explorer/memory-adapter.js

@@ -0,0 +1,250 @@
+import { basenameExplorerPath, dirnameExplorerPath, joinExplorerPath, } from "./path.js";
+import { cloneExplorerNodes } from "./tree.js";
+function listSiblingNames(nodes, parentPath) {
+    return ensureFolder(nodes, parentPath).map((node) => node.name);
+}
+function uniqueName(existing, base) {
+    if (!existing.includes(base))
+        return base;
+    let index = 1;
+    while (existing.includes(`${base} ${index}`))
+        index += 1;
+    return `${base} ${index}`;
+}
+function removeNode(nodes, path) {
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.path === path) {
+            nodes.splice(i, 1);
+            return node;
+        }
+        if (node.children) {
+            const removed = removeNode(node.children, path);
+            if (removed)
+                return removed;
+        }
+    }
+    return null;
+}
+function findNode(nodes, path) {
+    for (const node of nodes) {
+        if (node.path === path)
+            return node;
+        if (node.children) {
+            const found = findNode(node.children, path);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function ensureFolder(nodes, folderPath) {
+    if (!folderPath || folderPath === "/")
+        return nodes;
+    const parts = folderPath.split("/").filter(Boolean);
+    let current = nodes;
+    let currentPath = "";
+    for (const part of parts) {
+        currentPath = currentPath ? joinExplorerPath(currentPath, part) : part;
+        let folder = current.find((node) => node.path === currentPath && node.kind === "folder");
+        if (!folder) {
+            folder = {
+                path: currentPath,
+                name: part,
+                kind: "folder",
+                children: [],
+            };
+            current.push(folder);
+        }
+        folder.children ??= [];
+        current = folder.children;
+    }
+    return current;
+}
+function rewriteSubtree(node, nextPath) {
+    const next = {
+        ...node,
+        path: nextPath,
+        name: basenameExplorerPath(nextPath) || node.name,
+    };
+    if (next.kind === "folder") {
+        next.children = (node.children ?? []).map((child) => rewriteSubtree(child, joinExplorerPath(nextPath, child.name)));
+    }
+    else {
+        delete next.children;
+    }
+    return next;
+}
+export function createMemoryExplorerAdapter(seed = [], options = {}) {
+    let nodes = cloneExplorerNodes(seed);
+    const treeListeners = new Set();
+    const selectionListeners = new Set();
+    let autoReveal = options.autoReveal ?? false;
+    let showHiddenFiles = options.showHiddenFiles ?? false;
+    let activePath = null;
+    const openedPaths = [];
+    const openRequests = [];
+    const notifyTree = () => {
+        for (const listener of treeListeners)
+            listener();
+    };
+    const notifySelection = () => {
+        for (const listener of selectionListeners)
+            listener(activePath);
+    };
+    const actions = {
+        async openFile(path, options = { disposition: "current" }) {
+            openRequests.push({ path, options });
+            if (!openedPaths.includes(path))
+                openedPaths.push(path);
+            activePath = path;
+            notifySelection();
+        },
+        async createFile(parentPath) {
+            const siblings = listSiblingNames(nodes, parentPath);
+            const stemNames = siblings.map((name) => name.replace(/\.md$/i, ""));
+            const base = uniqueName(stemNames, "Untitled");
+            const name = `${base}.md`;
+            const path = joinExplorerPath(parentPath, name);
+            ensureFolder(nodes, parentPath).push({ path, name, kind: "file" });
+            notifyTree();
+            await actions.openFile(path);
+            return path;
+        },
+        async createFolder(parentPath) {
+            const siblings = listSiblingNames(nodes, parentPath);
+            const name = uniqueName(siblings, "Untitled");
+            const path = joinExplorerPath(parentPath, name);
+            ensureFolder(nodes, parentPath).push({
+                path,
+                name,
+                kind: "folder",
+                children: [],
+            });
+            notifyTree();
+            return path;
+        },
+        async rename(path, nextBaseName) {
+            const parent = dirnameExplorerPath(path);
+            const nextPath = joinExplorerPath(parent, nextBaseName);
+            if (nextPath === path)
+                return path;
+            const removed = removeNode(nodes, path);
+            if (!removed)
+                throw new Error(`Missing path: ${path}`);
+            ensureFolder(nodes, parent).push(rewriteSubtree(removed, nextPath));
+            if (activePath === path || activePath?.startsWith(`${path}/`)) {
+                activePath =
+                    activePath === path
+                        ? nextPath
+                        : `${nextPath}${activePath.slice(path.length)}`;
+                notifySelection();
+            }
+            notifyTree();
+            return nextPath;
+        },
+        async move(path, destinationFolderPath) {
+            const destination = destinationFolderPath.replace(/^\/+|\/+$/g, "");
+            if (dirnameExplorerPath(path) === destination)
+                return path;
+            const removed = removeNode(nodes, path);
+            if (!removed)
+                throw new Error(`Missing path: ${path}`);
+            const nextPath = joinExplorerPath(destination, removed.name);
+            ensureFolder(nodes, destination).push(rewriteSubtree(removed, nextPath));
+            if (activePath === path || activePath?.startsWith(`${path}/`)) {
+                activePath =
+                    activePath === path
+                        ? nextPath
+                        : `${nextPath}${activePath.slice(path.length)}`;
+                notifySelection();
+            }
+            notifyTree();
+            return nextPath;
+        },
+        async delete(path) {
+            const node = findNode(nodes, path);
+            if (!node)
+                return;
+            if (node.kind === "folder" && (node.children?.length ?? 0) > 0) {
+                throw new Error("Cannot delete a non-empty folder");
+            }
+            removeNode(nodes, path);
+            if (activePath === path) {
+                activePath = null;
+                notifySelection();
+            }
+            notifyTree();
+        },
+        async importExternalFiles(folderPath, files) {
+            const target = ensureFolder(nodes, folderPath);
+            for (const file of files) {
+                const path = joinExplorerPath(folderPath, file.name);
+                if (!findNode(nodes, path)) {
+                    target.push({ path, name: file.name, kind: "file" });
+                }
+            }
+            notifyTree();
+        },
+        async copyText(_label, value) {
+            if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+                await navigator.clipboard.writeText(value);
+            }
+        },
+    };
+    return {
+        tree: {
+            listEntries() {
+                return cloneExplorerNodes(nodes);
+            },
+            subscribe(onChange) {
+                treeListeners.add(onChange);
+                return () => treeListeners.delete(onChange);
+            },
+        },
+        actions,
+        selection: {
+            subscribe(onActivePath) {
+                selectionListeners.add(onActivePath);
+                onActivePath(activePath);
+                return () => selectionListeners.delete(onActivePath);
+            },
+        },
+        preferences: {
+            getAutoReveal() {
+                return autoReveal;
+            },
+            setAutoReveal(value) {
+                autoReveal = value;
+            },
+            getShowHiddenFiles() {
+                return showHiddenFiles;
+            },
+            setShowHiddenFiles(value) {
+                showHiddenFiles = value;
+            },
+        },
+        get nodes() {
+            return cloneExplorerNodes(nodes);
+        },
+        get openedPaths() {
+            return [...openedPaths];
+        },
+        get openRequests() {
+            return openRequests.map((request) => ({
+                path: request.path,
+                options: { ...request.options },
+            }));
+        },
+        setActivePath(path) {
+            activePath = path;
+            notifySelection();
+        },
+        setAutoRevealValue(value) {
+            autoReveal = value;
+        },
+        setShowHiddenFilesValue(value) {
+            showHiddenFiles = value;
+        },
+    };
+}

package/dist/shared/workspace/explorer/path.d.ts

@@ -0,0 +1,6 @@
+/** Join vault-relative path segments. Root is represented as `""` or `"/"`. */
+export declare function joinExplorerPath(...parts: string[]): string;
+export declare function dirnameExplorerPath(path: string): string;
+export declare function basenameExplorerPath(path: string): string;
+export declare function ancestorExplorerPaths(path: string): string[];
+export declare function parentExplorerPath(path: string): string;

package/dist/shared/workspace/explorer/path.js

@@ -0,0 +1,36 @@
+/** Join vault-relative path segments. Root is represented as `""` or `"/"`. */
+export function joinExplorerPath(...parts) {
+    const segments = parts
+        .flatMap((part) => part.split("/"))
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0 && part !== ".");
+    return segments.join("/");
+}
+export function dirnameExplorerPath(path) {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!normalized)
+        return "";
+    const index = normalized.lastIndexOf("/");
+    return index === -1 ? "" : normalized.slice(0, index);
+}
+export function basenameExplorerPath(path) {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!normalized)
+        return "";
+    const index = normalized.lastIndexOf("/");
+    return index === -1 ? normalized : normalized.slice(index + 1);
+}
+export function ancestorExplorerPaths(path) {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!normalized)
+        return [];
+    const segments = normalized.split("/");
+    const ancestors = [];
+    for (let i = 1; i <= segments.length; i++) {
+        ancestors.push(segments.slice(0, i).join("/"));
+    }
+    return ancestors;
+}
+export function parentExplorerPath(path) {
+    return dirnameExplorerPath(path);
+}

package/dist/shared/workspace/explorer/tree.d.ts

@@ -0,0 +1,11 @@
+import type { ExplorerNode, ExplorerSortMode } from "./types.js";
+export declare function compareExplorerNodes(left: ExplorerNode, right: ExplorerNode, sortMode: ExplorerSortMode): number;
+export declare function sortExplorerChildren(node: ExplorerNode, sortMode: ExplorerSortMode): void;
+/** Rebuild a rooted folder tree from a flat (or nested) entry list. */
+export declare function buildExplorerTree(entries: ExplorerNode[], sortMode: ExplorerSortMode): ExplorerNode;
+export declare function findExplorerNode(root: ExplorerNode, path: string): ExplorerNode | undefined;
+export declare function isHiddenExplorerName(name: string): boolean;
+/** Drop dot-named nodes and their descendants unless show-hidden is on. */
+export declare function filterHiddenExplorerTree(root: ExplorerNode, showHidden: boolean): ExplorerNode;
+export declare function collectFolderPaths(root: ExplorerNode): string[];
+export declare function cloneExplorerNodes(nodes: ExplorerNode[]): ExplorerNode[];

package/dist/shared/workspace/explorer/tree.js

@@ -0,0 +1,143 @@
+import { joinExplorerPath } from "./path.js";
+export function compareExplorerNodes(left, right, sortMode) {
+    if (left.kind !== right.kind) {
+        return left.kind === "folder" ? -1 : 1;
+    }
+    const direction = sortMode === "name-desc" ? -1 : 1;
+    return (direction *
+        (left.name.localeCompare(right.name, undefined, {
+            numeric: true,
+            sensitivity: "base",
+        }) ||
+            left.path.localeCompare(right.path, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            })));
+}
+export function sortExplorerChildren(node, sortMode) {
+    if (node.kind !== "folder" || !node.children)
+        return;
+    node.children.sort((left, right) => compareExplorerNodes(left, right, sortMode));
+    for (const child of node.children) {
+        sortExplorerChildren(child, sortMode);
+    }
+}
+/** Rebuild a rooted folder tree from a flat (or nested) entry list. */
+export function buildExplorerTree(entries, sortMode) {
+    const root = {
+        path: "/",
+        name: "/",
+        kind: "folder",
+        children: [],
+    };
+    const lookup = new Map();
+    lookup.set("", root);
+    lookup.set("/", root);
+    const flat = [];
+    const visit = (node) => {
+        if (node.path !== "/" && node.path !== "") {
+            flat.push({
+                path: node.path.replace(/^\/+|\/+$/g, ""),
+                name: node.name,
+                kind: node.kind,
+            });
+        }
+        if (node.children) {
+            for (const child of node.children)
+                visit(child);
+        }
+    };
+    for (const entry of entries)
+        visit(entry);
+    for (const entry of flat) {
+        if (!entry.path)
+            continue;
+        const parts = entry.path.split("/").filter(Boolean);
+        let currentPath = "";
+        let parent = root;
+        for (let i = 0; i < parts.length; i++) {
+            const name = parts[i];
+            currentPath = currentPath ? joinExplorerPath(currentPath, name) : name;
+            const isLast = i === parts.length - 1;
+            let node = lookup.get(currentPath);
+            if (!node) {
+                node = {
+                    path: currentPath,
+                    name,
+                    kind: isLast ? entry.kind : "folder",
+                    children: isLast && entry.kind === "file" ? undefined : [],
+                };
+                lookup.set(currentPath, node);
+                parent.children ??= [];
+                parent.children.push(node);
+            }
+            else if (isLast) {
+                node.kind = entry.kind;
+                node.name = name;
+                if (entry.kind === "folder") {
+                    node.children ??= [];
+                }
+                else {
+                    delete node.children;
+                }
+            }
+            parent = node;
+        }
+    }
+    sortExplorerChildren(root, sortMode);
+    return root;
+}
+export function findExplorerNode(root, path) {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!normalized || normalized === "/")
+        return root;
+    const parts = normalized.split("/");
+    let current = root;
+    let currentPath = "";
+    for (const part of parts) {
+        currentPath = currentPath ? joinExplorerPath(currentPath, part) : part;
+        current = current?.children?.find((child) => child.path === currentPath);
+        if (!current)
+            return undefined;
+    }
+    return current;
+}
+export function isHiddenExplorerName(name) {
+    return name.startsWith(".");
+}
+/** Drop dot-named nodes and their descendants unless show-hidden is on. */
+export function filterHiddenExplorerTree(root, showHidden) {
+    if (showHidden)
+        return root;
+    const visit = (node) => {
+        if (!node.children)
+            return node;
+        return {
+            ...node,
+            children: node.children
+                .filter((child) => !isHiddenExplorerName(child.name))
+                .map(visit),
+        };
+    };
+    return visit(root);
+}
+export function collectFolderPaths(root) {
+    const paths = [];
+    const visit = (node) => {
+        if (node.kind === "folder" && node.path !== "/" && node.path !== "") {
+            paths.push(node.path);
+        }
+        for (const child of node.children ?? [])
+            visit(child);
+    };
+    visit(root);
+    return paths;
+}
+export function cloneExplorerNodes(nodes) {
+    return nodes.map((node) => ({
+        path: node.path,
+        name: node.name,
+        kind: node.kind,
+        children: node.children ? cloneExplorerNodes(node.children) : undefined,
+    }));
+}

package/dist/shared/workspace/explorer/types.d.ts

@@ -0,0 +1,83 @@
+import type { WorkspaceIconName } from "../core/types.js";
+import type { WorkspaceMenu } from "../core/workspace-menu.js";
+export type ExplorerNodeKind = "file" | "folder";
+export type ExplorerSortMode = "name-asc" | "name-desc";
+/** Stable path-based tree node. Paths are vault-relative; root is `"/"`. */
+export interface ExplorerNode {
+    path: string;
+    name: string;
+    kind: ExplorerNodeKind;
+    children?: ExplorerNode[];
+}
+export interface ExplorerIconContext {
+    selectedPath: string;
+    opened: boolean;
+    editing: boolean;
+}
+export interface ExplorerRevealState {
+    path: string;
+    isFlashing: boolean;
+}
+export interface ExplorerLabels {
+    files: string;
+    openingVault: string;
+    createFile: string;
+    createFolder: string;
+    sortFiles: string;
+    filenameAsc: string;
+    filenameDesc: string;
+    autoReveal: string;
+    showHiddenFiles: string;
+    toggleCollapse: string;
+    newNote: string;
+    newFolder: string;
+    copyPath: string;
+    fromVaultFolder: string;
+    rename: string;
+    refresh: string;
+    delete: string;
+}
+export declare const DEFAULT_EXPLORER_LABELS: ExplorerLabels;
+export interface ExplorerTreeAdapter {
+    listEntries(): Promise<ExplorerNode[]> | ExplorerNode[];
+    subscribe(onChange: () => void): () => void;
+}
+export type ExplorerOpenDisposition = "current" | "reveal-or-new-tab" | "new-tab";
+export interface ExplorerOpenFileOptions {
+    disposition: ExplorerOpenDisposition;
+}
+export interface ExplorerActionsAdapter {
+    openFile(path: string, options?: ExplorerOpenFileOptions): void | Promise<void>;
+    createFile(parentPath: string): Promise<string>;
+    createFolder(parentPath: string): Promise<string>;
+    rename(path: string, nextBaseName: string): Promise<string>;
+    move(path: string, destinationFolderPath: string): Promise<string>;
+    delete(path: string): Promise<void>;
+    importExternalFiles?(folderPath: string, files: File[]): Promise<void>;
+    copyText?(label: string, value: string): Promise<void>;
+}
+export interface ExplorerSelectionAdapter {
+    subscribe(onActivePath: (path: string | null) => void): () => void;
+}
+export interface ExplorerPreferencesAdapter {
+    getAutoReveal(): boolean | Promise<boolean>;
+    setAutoReveal(value: boolean): void | Promise<void>;
+    getShowHiddenFiles(): boolean | Promise<boolean>;
+    setShowHiddenFiles(value: boolean): void | Promise<void>;
+}
+export type ExplorerGetIcon = (node: ExplorerNode, context: ExplorerIconContext) => WorkspaceIconName | null | undefined;
+export type ExplorerBuildItemMenu = (menu: WorkspaceMenu, node: ExplorerNode, source: "explorer") => void;
+export type ExplorerFileDragStart = (node: ExplorerNode, event: DragEvent) => void;
+export interface ExplorerControllerOptions {
+    tree: ExplorerTreeAdapter;
+    actions: ExplorerActionsAdapter;
+    selection?: ExplorerSelectionAdapter;
+    preferences?: ExplorerPreferencesAdapter;
+    getIcon?: ExplorerGetIcon;
+    buildItemMenu?: ExplorerBuildItemMenu;
+    onFileDragStart?: ExplorerFileDragStart;
+    labels?: Partial<ExplorerLabels>;
+    /** Initial loading gate (vault still opening). */
+    loading?: boolean;
+    sortMode?: ExplorerSortMode;
+}

package/dist/shared/workspace/explorer/types.js

@@ -0,0 +1,19 @@
+export const DEFAULT_EXPLORER_LABELS = {
+    files: "Files",
+    openingVault: "Opening vault",
+    createFile: "Create File",
+    createFolder: "Create Folder",
+    sortFiles: "Sort Files",
+    filenameAsc: "Filename (A to Z)",
+    filenameDesc: "Filename (Z to A)",
+    autoReveal: "Auto-reveal current file",
+    showHiddenFiles: "Show hidden files",
+    toggleCollapse: "Toggle collapse",
+    newNote: "New note",
+    newFolder: "New folder",
+    copyPath: "Copy Path",
+    fromVaultFolder: "From vault folder",
+    rename: "Rename...",
+    refresh: "Refresh",
+    delete: "Delete",
+};

package/dist/shared/workspace/floating-layer/WorkspaceFloatingLayer.css

@@ -0,0 +1,19 @@
+.ui-workspace-floating-layer {
+  position: fixed;
+  z-index: calc(var(--ui-workspace-overlay-z-index) - 5);
+  inset: 0;
+  pointer-events: none;
+}
+
+.ui-workspace-floating-layer__minimized {
+  position: absolute;
+  bottom: 1rem;
+  left: 50%;
+  display: flex;
+  max-width: calc(100svw - 2rem);
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 0.5rem;
+  transform: translateX(-50%);
+  pointer-events: none;
+}

package/dist/shared/workspace/floating-layer/WorkspaceFloatingLayer.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import type { WorkspaceTab } from "../core/types.js";
+  import type { WorkspaceShellController } from "../core/workspace-controller.svelte.js";
+  import { WorkspaceDragState } from "../drag/workspace-drag.svelte.js";
+  import WorkspaceFloatingWindow from "../floating-window/WorkspaceFloatingWindow.svelte";
+  import "./WorkspaceFloatingLayer.css";
+
+  let {
+    controller,
+    createTab,
+    boundsRoot,
+    drag,
+  }: {
+    controller: WorkspaceShellController;
+    createTab?: (paneId: string) => WorkspaceTab;
+    boundsRoot?: HTMLElement | null;
+    drag?: WorkspaceDragState;
+  } = $props();
+
+  const createDrag = () => new WorkspaceDragState(controller);
+  const internalDrag = createDrag();
+  let dragState = $derived(drag ?? internalDrag);
+  let windows = $derived(
+    controller.layout.windows.filter((entry) => entry.mode === "floating"),
+  );
+  let minimized = $derived(
+    windows.filter((entry) => entry.state === "minimized"),
+  );
+  let free = $derived(windows.filter((entry) => entry.state !== "minimized"));
+</script>
+
+{#if windows.length}
+  <div
+    class="ui-workspace-floating-layer"
+    data-ui-component="workspace-floating-layer"
+    data-ui-part="root"
+    data-app-shell-floating-layer
+  >
+    {#each free as workspaceWindow (workspaceWindow.id)}
+      <WorkspaceFloatingWindow
+        {controller}
+        window={workspaceWindow}
+        drag={dragState}
+        {createTab}
+        {boundsRoot}
+      />
+    {/each}
+
+    {#if minimized.length}
+      <div
+        class="ui-workspace-floating-layer__minimized"
+        data-ui-part="minimized-stack"
+        data-floating-minimized-stack="true"
+      >
+        {#each minimized as workspaceWindow (workspaceWindow.id)}
+          <WorkspaceFloatingWindow
+            {controller}
+            window={workspaceWindow}
+            drag={dragState}
+            {createTab}
+            {boundsRoot}
+            dockMode="minimized"
+          />
+        {/each}
+      </div>
+    {/if}
+  </div>
+{/if}

package/dist/shared/workspace/floating-layer/WorkspaceFloatingLayer.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { WorkspaceTab } from "../core/types.js";
+import type { WorkspaceShellController } from "../core/workspace-controller.svelte.js";
+import { WorkspaceDragState } from "../drag/workspace-drag.svelte.js";
+import "./WorkspaceFloatingLayer.css";
+type $$ComponentProps = {
+    controller: WorkspaceShellController;
+    createTab?: (paneId: string) => WorkspaceTab;
+    boundsRoot?: HTMLElement | null;
+    drag?: WorkspaceDragState;
+};
+declare const WorkspaceFloatingLayer: import("svelte").Component<$$ComponentProps, {}, "">;
+type WorkspaceFloatingLayer = ReturnType<typeof WorkspaceFloatingLayer>;
+export default WorkspaceFloatingLayer;

package/dist/shared/workspace/floating-layer/index.d.ts

@@ -0,0 +1 @@
+export { default as WorkspaceFloatingLayer } from "./WorkspaceFloatingLayer.svelte";

package/dist/shared/workspace/floating-layer/index.js

@@ -0,0 +1 @@
+export { default as WorkspaceFloatingLayer } from "./WorkspaceFloatingLayer.svelte";