@floegence/floe-webapp-core 0.48.5 → 0.49.0

package/dist/components/ui/picker/PickerNavigation.d.ts

@@ -0,0 +1,91 @@
+import type { FileItem } from '../../file-browser/types';
+export interface PickerRoot {
+    id: string;
+    label: string;
+    pathAbs: string;
+    permissions?: Readonly<{
+        read: boolean;
+        write: boolean;
+    }>;
+    hidden?: boolean;
+}
+export interface PickerPathContext {
+    homePathAbs: string;
+    defaultRootId: string;
+    roots: readonly PickerRoot[];
+}
+export type PickerDirectoryLoader = (path: string, options: {
+    showHidden: boolean;
+}) => Promise<readonly FileItem[]>;
+export interface PickerCopy {
+    path: string;
+    go: string;
+    roots: string;
+    root: string;
+    showHidden: string;
+    loading: string;
+    retry: string;
+    empty: string;
+    emptyFiles: string;
+    invalidPath: string;
+    missingPath: string;
+    unavailableContext: string;
+    loadFailed: string;
+    currentDirectory: string;
+    newFolder: string;
+    folderName: string;
+    create: string;
+    cancel: string;
+    fileName: string;
+    fileNameRequired: string;
+    noFilesSelected: string;
+    selectionLimit: string;
+    selectedCount: (count: number) => string;
+}
+export declare const defaultPickerCopy: PickerCopy;
+export interface PickerDataProps {
+    /** Static trees contain absolute paths. Remote consumers provide loadDirectory instead. */
+    files?: readonly FileItem[];
+    pathContext?: PickerPathContext;
+    /** Refreshed on every open, scope change, and explicit context retry. */
+    loadPathContext?: () => Promise<PickerPathContext>;
+    loadDirectory?: PickerDirectoryLoader;
+    /** Changing environment/session identity invalidates all pending work. */
+    scopeKey?: string;
+    initialPath?: string;
+    /** Display-only Home hint for static pickers; never rebases a path. */
+    homePath?: string;
+    homeLabel?: string;
+    initialShowHidden?: boolean;
+    filter?: (item: FileItem) => boolean;
+    copy?: Partial<PickerCopy>;
+    formatError?: (error: unknown) => string;
+    onValidityChange?: (valid: boolean) => void;
+}
+export declare class PickerNavigationError extends Error {
+    readonly kind: 'invalidPath' | 'missingPath' | 'unavailableContext';
+    constructor(kind: 'invalidPath' | 'missingPath' | 'unavailableContext');
+}
+/** Absolute POSIX paths only. The runtime remains responsible for canonical/symlink resolution. */
+export declare function parsePickerPath(rawPath: string, homePathAbs?: string): string;
+export declare function pickerParentPath(path: string): string;
+export declare function formatPickerPath(path: string, homePathAbs?: string): string;
+/** Owns one committed directory and latest navigation. No cached tree can authorize a path. */
+export declare function createFilesystemPickerDataSource(getProps: () => PickerDataProps, onValidated?: (path: string) => void): {
+    context: import("solid-js").Accessor<PickerPathContext | null>;
+    currentPath: import("solid-js").Accessor<string>;
+    entries: import("solid-js").Accessor<readonly FileItem[]>;
+    pathInput: import("solid-js").Accessor<string>;
+    pending: import("solid-js").Accessor<boolean>;
+    error: import("solid-js").Accessor<unknown>;
+    showHidden: import("solid-js").Accessor<boolean>;
+    active: import("solid-js").Accessor<boolean>;
+    valid: () => boolean;
+    open: (path?: string) => Promise<void>;
+    close: () => void;
+    navigate: (rawPath: string) => Promise<boolean>;
+    setPathInput(value: string): void;
+    setShowHidden(value: boolean): Promise<void>;
+    retry(): Promise<void>;
+};
+export type FilesystemPickerDataSource = ReturnType<typeof createFilesystemPickerDataSource>;

package/dist/components/ui/picker/PickerNavigation.js

@@ -0,0 +1,160 @@
+import { createSignal as l, onCleanup as z, batch as d } from "solid-js";
+const J = {
+  path: "Directory path",
+  go: "Go",
+  roots: "Locations",
+  root: "Root",
+  showHidden: "Show hidden items",
+  loading: "Loading directory…",
+  retry: "Retry",
+  empty: "No directories here",
+  emptyFiles: "No matching files in this directory",
+  invalidPath: "Enter an absolute path or a path starting with ~/",
+  missingPath: "Directory not found",
+  unavailableContext: "Filesystem locations are unavailable",
+  loadFailed: "Could not load directory",
+  currentDirectory: "Current directory",
+  newFolder: "New folder",
+  folderName: "Folder name",
+  create: "Create",
+  cancel: "Cancel",
+  fileName: "File name",
+  fileNameRequired: "Filename is required",
+  noFilesSelected: "No files selected",
+  selectionLimit: "Selection limit reached",
+  selectedCount: (t) => `${t} selected`
+};
+class S extends Error {
+  constructor(n) {
+    super(n), this.kind = n;
+  }
+}
+function g(t, n = "") {
+  let e = String(t ?? "").trim();
+  if (e === "~" ? e = n : e.startsWith("~/") && (e = n ? `${n}/${e.slice(2)}` : ""), !e.startsWith("/") || e.includes("\0")) return "";
+  const u = [];
+  for (const o of e.split("/"))
+    !o || o === "." || (o === ".." ? u.pop() : u.push(o));
+  return `/${u.join("/")}`;
+}
+function Q(t) {
+  const n = g(t);
+  return n.slice(0, n.lastIndexOf("/")) || "/";
+}
+function U(t, n = "") {
+  const e = g(n);
+  return e && t === e ? "~" : e && e !== "/" && t.startsWith(`${e}/`) ? `~${t.slice(e.length)}` : t;
+}
+function j(t, n) {
+  if (n === "/") return t;
+  for (const e of t)
+    if (e.type === "folder") {
+      if (g(e.path) === n) return e.children ?? [];
+      if (e.children)
+        try {
+          return j(e.children, n);
+        } catch {
+        }
+    }
+  throw new S("missingPath");
+}
+function V(t, n) {
+  const [e, u] = l(null), [o, H] = l(""), [B, N] = l([]), [v, C] = l(""), [$, c] = l(!1), [k, f] = l(null), [I, q] = l(!1), [h, R] = l(!1);
+  let p = 0, b = 0, A, w = /* @__PURE__ */ new Map();
+  const G = () => h() && !$() && !k() && !!o() && g(v(), e()?.homePathAbs) === o(), L = () => {
+    p += 1, b += 1, w = /* @__PURE__ */ new Map();
+  }, W = () => {
+    L(), d(() => {
+      R(!1), c(!1);
+    });
+  };
+  z(W);
+  const x = async (i) => {
+    if (!h() || !e()) return !1;
+    const D = p, a = ++b, r = g(i, e()?.homePathAbs);
+    d(() => {
+      C(i), f(null), c(!0);
+    });
+    const y = () => h() && p === D && b === a;
+    try {
+      if (!r) throw new S("invalidPath");
+      const s = t(), m = { showHidden: I() }, F = `${r}\0${m.showHidden}`;
+      let P = w.get(F);
+      P || (P = Promise.resolve().then(() => s.loadDirectory ? s.loadDirectory(r, m) : j(s.files ?? [], r)), w.set(F, P));
+      let E;
+      try {
+        E = await P;
+      } finally {
+        w.get(F) === P && w.delete(F);
+      }
+      if (!y()) return !1;
+      const O = s.loadDirectory || m.showHidden ? E : E.filter((T) => !T.name.startsWith("."));
+      return d(() => {
+        H(r), N(O), C(r), c(!1), f(null);
+      }), n?.(r), !0;
+    } catch (s) {
+      return y() && d(() => {
+        f(s), c(!1);
+      }), !1;
+    }
+  }, M = async (i) => {
+    L();
+    const D = p;
+    A = i;
+    const a = t();
+    d(() => {
+      R(!0), u(null), H(""), N([]), C(i ?? ""), c(!0), f(null), q(a.initialShowHidden ?? !a.loadDirectory);
+    });
+    try {
+      const r = a.loadPathContext ? await a.loadPathContext() : a.pathContext;
+      if (!h() || p !== D) return;
+      if (!r && a.loadDirectory) throw new S("unavailableContext");
+      const y = r ?? {
+        homePathAbs: a.homePath ?? "",
+        defaultRootId: "root",
+        roots: [{ id: "root", label: a.homeLabel ?? J.root, pathAbs: "/" }]
+      };
+      u(y);
+      const s = i || y.roots.find((m) => m.id === y.defaultRootId)?.pathAbs;
+      if (!s) throw new S("unavailableContext");
+      await x(s);
+    } catch (r) {
+      h() && p === D && d(() => {
+        f(r), c(!1);
+      });
+    }
+  };
+  return {
+    context: e,
+    currentPath: o,
+    entries: B,
+    pathInput: v,
+    pending: $,
+    error: k,
+    showHidden: I,
+    active: h,
+    valid: G,
+    open: M,
+    close: W,
+    navigate: x,
+    setPathInput(i) {
+      b += 1, d(() => {
+        C(i), c(!1), f(null);
+      });
+    },
+    async setShowHidden(i) {
+      q(i), await x(v() || o());
+    },
+    async retry() {
+      e() ? await x(v() || o()) : await M(A);
+    }
+  };
+}
+export {
+  S as PickerNavigationError,
+  V as createFilesystemPickerDataSource,
+  J as defaultPickerCopy,
+  U as formatPickerPath,
+  g as parsePickerPath,
+  Q as pickerParentPath
+};

package/dist/components/workbench/WorkbenchWidget.js

@@ -130,8 +130,8 @@ function Qe(i) {
     widgetRoot: w ?? null,
     interactiveSelector: h().interactiveSelector,
     panSurfaceSelector: h().panSurfaceSelector
-  }), ae = () => {
-    F(), w?.focus({
+  }), ae = (t) => {
+    F(), t?.focus !== !1 && w?.focus({
       preventScroll: !0
     });
   }, _t = (t) => {

package/dist/components/workbench/types.d.ts

@@ -103,7 +103,10 @@ export interface WorkbenchWidgetBodyProps<TWidgetType extends string = Workbench
     motion?: WorkbenchWidgetMotionIntent | null;
     selected?: boolean;
     filtered?: boolean;
-    requestActivate?: () => void;
+    /** Select and raise the widget. Set focus to false for local or embedded input observations. */
+    requestActivate?: (options?: {
+        focus?: boolean;
+    }) => void;
 }
 export interface WorkbenchWidgetDefinition<TWidgetType extends string = WorkbenchWidgetType> {
     type: TWidgetType;