@brftech/filex-core 0.42.2 → 0.43.0

package/src/lib/listing.ts

@@ -6,10 +6,12 @@
  * must be identical in both, otherwise split view shows mismatched rows
  * (the trash row missing on one side → visible row-offset).
  */
+import type { TagKind } from './tags';
 import { ref } from 'vue';
 
 import type { FileNode } from '../types/FileNode';
 import { E2E_MARKER_NAME } from './e2ecrypto';
+import { isInternalName, isInternalPath } from './internalPaths';
 
 /** Adapter-strip: `s3-test://fileman/x` → `fileman/x`. */
 export function stripAdapter(p: string): string {
@@ -39,24 +41,21 @@ export function parentDirOf(path: string): string {
 }
 
 /**
- * Hide system/internal entries the user must never see as files:
- * thumbnails, version history, the soft-delete store, keepdir markers,
- * the desktop app's open-with scratch area and the E2E marker. Shared by
- * both panes' listing filters.
+ * Hide system/internal entries the user must never see as files: filex's own
+ * directories and the keep marker (lib/internalPaths — the one client list,
+ * held equal to the server's by a test), the virtual `.trash` row, and the E2E
+ * marker. Shared by both panes' listing filters.
+ *
+ * ⚠ Absolute, not a "hidden files" preference: a user who has switched hidden
+ * files on is asking to see their OWN dotfiles, not ours. The server already
+ * leaves these out of every listing; this is the seatbelt for an embed talking
+ * to an older server — which is also why it judges the whole PATH, so a search
+ * hit such a server returns from inside `.filex-open` is dropped too.
  */
 export function filterInternalEntries(files: FileNode[]): FileNode[] {
   return (files || []).filter((f) => {
-    if (f.path.includes('.thumbs')) return false;
-    if (f.path.includes('.versions') || f.basename === '.versions') return false;
+    if (isInternalName(f.basename) || isInternalPath(f.path)) return false;
     if (f.basename === '.trash') return false;
-    // The desktop app's "open this document with filex" scratch area. Real
-    // files live in it for the length of one editing session, but they are the
-    // app's plumbing, not the user's documents -- and a user who has switched
-    // hidden files on is asking to see their OWN dotfiles, not ours. Hidden
-    // absolutely, like .filex-trash and .versions; stale copies are swept by
-    // the desktop app itself, not by hand.
-    if (f.basename === '.filex-open') return false;
-    if (f.basename === '.keepdir') return false;
     if (f.basename === E2E_MARKER_NAME) return false;
     return true;
   });
@@ -272,16 +271,50 @@ export const VIRTUAL_SEGMENTS: Record<string, string> = {
  */
 export const TAG_SEGMENT_PREFIX = '.tag~';
 
-/** `invoices` → `.tag~invoices`. */
-export function makeTagSegment(tag: string): string {
-  return `${TAG_SEGMENT_PREFIX}${tag}`;
+/**
+ * etiket:k2 (v0.43.0) — the KIND of a tag view. A person can have a personal
+ * "rapor" and their team a "rapor"; the navigation panel lists them apart, so
+ * each opens its own view: `.mytag~rapor` (personal), `.teamtag~rapor` (team).
+ * The plain `.tag~rapor` stays and means BOTH — every link and restored tab
+ * from before kinds existed keeps opening what it opened then.
+ *
+ * ⚠ Listed longest-first is not needed (no prefix is a prefix of another),
+ * but every reader goes through `tagViewOfSegment`, never a `startsWith` of
+ * its own, so a fourth kind would be one line here.
+ */
+const TAG_KIND_PREFIXES: ReadonlyArray<readonly [string, TagKind | '']> = [
+  ['.mytag~', 'personal'],
+  ['.teamtag~', 'team'],
+  [TAG_SEGMENT_PREFIX, ''],
+];
+
+/** `invoices` → `.tag~invoices`; with a kind, `.mytag~` / `.teamtag~`. */
+export function makeTagSegment(tag: string, kind: TagKind | '' = ''): string {
+  const prefix = TAG_KIND_PREFIXES.find(([, k]) => k === kind)?.[0] ?? TAG_SEGMENT_PREFIX;
+  return `${prefix}${tag}`;
+}
+
+/** A tag-view segment's name and kind ('' = both), or null for anything else
+ *  (a bare `.tag~` included). */
+export function tagViewOfSegment(segment: string): { tag: string; kind: TagKind | '' } | null {
+  for (const [prefix, kind] of TAG_KIND_PREFIXES) {
+    if (segment.startsWith(prefix)) {
+      const tag = segment.slice(prefix.length);
+      return tag ? { tag, kind } : null;
+    }
+  }
+  return null;
 }
 
-/** `.tag~invoices` → `invoices`; '' for anything else (incl. a bare `.tag~`). */
+/** `.tag~invoices` (or `.mytag~` / `.teamtag~`) → `invoices`; '' otherwise. */
 export function tagOfSegment(segment: string): string {
-  return segment.startsWith(TAG_SEGMENT_PREFIX)
-    ? segment.slice(TAG_SEGMENT_PREFIX.length)
-    : '';
+  return tagViewOfSegment(segment)?.tag ?? '';
+}
+
+/** The kind of a tag-view path: 'personal', 'team', or '' (both / not a tag view). */
+export function tagKindOfPath(path: string): TagKind | '' {
+  const clean = (path || '').replace(/^\/+|\/+$/g, '');
+  return tagViewOfSegment(clean.split('/').pop() || clean)?.kind ?? '';
 }
 
 /** True when `path` (user-facing form) IS a tag listing. */
@@ -308,8 +341,10 @@ export function virtualSegmentKey(segment: string): string {
 export function virtualSegmentLabel(segment: string, t: (key: string) => string): string {
   const key = VIRTUAL_SEGMENTS[segment];
   if (key) return t(key);
-  const tag = tagOfSegment(segment);
-  return tag ? `#${tag}` : '';
+  const view = tagViewOfSegment(segment);
+  if (!view) return '';
+  // etiket:k2 — the crumb says whose tag this is: "#rapor · Kişisel".
+  return view.kind ? `#${view.tag} · ${t(`tags.kind.${view.kind}`)}` : `#${view.tag}`;
 }
 
 /**

package/src/lib/modalStack.ts

@@ -0,0 +1,26 @@
+/**
+ * modalStack — which explorer dialog is on top.
+ *
+ * Every open `modals/Modal.vue` registers here, and only the LAST one
+ * answers the keyboard (Escape, the Tab trap). Two dialogs open at once is
+ * ordinary — a confirmation over a plugin's screen, the destination picker
+ * over a move — and Escape must close the one in front, not both.
+ *
+ * ⚠ Module state on purpose: `<script setup>` top-level declarations are
+ * per INSTANCE, so a stack declared inside the component would hold one
+ * entry per dialog and every dialog would think it was on top.
+ */
+const stack: symbol[] = [];
+
+export function pushModal(id: symbol): void {
+  stack.push(id);
+}
+
+export function popModal(id: symbol): void {
+  const i = stack.lastIndexOf(id);
+  if (i >= 0) stack.splice(i, 1);
+}
+
+export function isTopModal(id: symbol): boolean {
+  return stack[stack.length - 1] === id;
+}

package/src/lib/nodeRow.ts

@@ -52,6 +52,15 @@ export function nodeRowToFileNode(
   if (ctx.multiStorageRoot && !storageName) return null;
   const name = String(row.name ?? rel.split('/').pop() ?? '');
   const isDir = row.type === 'dir';
+  /* issue #34 — these endpoints answer with the raw node row, so `type` here
+     is `model.NodeType`: 'file', 'dir' OR 'symlink'. The listing projector
+     collapses that third value to 'file' and sets a `symlink` flag beside it;
+     `handlers/meta.go` does not, because it ships the node struct as it is.
+     Without this line a link the server will not follow appears on Recent,
+     Starred, a tag view or the Home tray as a plain file with no badge and no
+     explanation — the same fix reaching the folder listing and stopping at
+     the view beside it, which is the split lesson #174 was written about. */
+  const isSymlink = row.type === 'symlink';
   const size = typeof row.size === 'number' ? row.size : 0;
   const id = typeof row.id === 'number' ? row.id : undefined;
   /* ⚠⚠ THE CONTEXT MENU MUST BE THE SAME EVERYWHERE (owner, 2026-09-19). The
@@ -98,9 +107,15 @@ export function nodeRowToFileNode(
     mime_type: typeof row.mime === 'string' ? row.mime : '',
     ...(perm ? { perm } : {}),
     read_only: readOnly,
-    // Keyed by node id. A file with no rendered thumbnail 404s here and the
-    // view falls back to its icon — the contract the ordinary listing has too.
-    thumb_url: !isDir && id !== undefined ? `/api/files/thumb/${id}` : undefined,
+    ...(isSymlink ? { symlink: true } : {}),
+    // ⚠⚠ The SERVER's `thumb_url`, never one built here. It used to be
+    // `/api/files/thumb/<id>` for every file, and the endpoint answers
+    // `404 "not ready"` for everything it has not rendered — a docx, a
+    // markdown note, a diagram: opening Recent with ten such files fired ten
+    // requests and all ten 404'd (2026-09-21). The rows now carry the URL
+    // exactly when there is an image behind it (handlers/meta.go, the folder
+    // listing's rule), so a file with none is never asked about.
+    thumb_url: !isDir && typeof row.thumb_url === 'string' && row.thumb_url ? row.thumb_url : undefined,
     extra_metadata: {},
   } as unknown as FileNode;
 }

package/src/lib/pdfFieldRules.ts

@@ -0,0 +1,126 @@
+/**
+ * pdfFieldRules — what a `text` field on a PDF will accept, as pure data.
+ *
+ * A signing app does not only want "a box for some words": it wants a tax
+ * number that is digits, a date in the shape the paper form prints, an
+ * address that fits the line. So a `text` field may carry a `rule`, and the
+ * browser enforces it WHILE the person types rather than after they submit —
+ * an invalid signature page that only says so on the way out is a page that
+ * gets signed twice.
+ *
+ * ⚠ The rule travels back to the plugin with the value
+ * (`{fields: [{id, value, font?, rule?}]}`, docs/APP-PLUGINS-API.md →
+ * `pdf-fields` props) so the stamper formats what it is handed instead of
+ * guessing from the string: `01/02/2026` is a date to a rule and ambiguous
+ * text to a parser.
+ *
+ * ⚠ This is a CONVENIENCE, not a security boundary. The browser is the only
+ * thing that runs it; a plugin that cares re-checks what it is given. Same
+ * relationship `applies` has with the server's re-check.
+ */
+
+/**
+ * What a `text` field accepts. `any` is the default and means "anything".
+ *
+ * ⚠⚠ v3 §3.3 — there is no `date` rule any more. `date` is a FIELD TYPE,
+ * and two ways to ask for the same thing is how you get two answers: a date
+ * placed as a date field arrived as `YYYY-MM-DD` and a date typed into a text
+ * field under the old rule arrived as `DD/MM/YYYY`, so the stamping plugin
+ * had to guess which of its own boxes it was looking at. An older manifest's
+ * `kind: "date"` is read as `any` rather than refused — the box keeps taking
+ * what the person types, it just stops pretending to be a second date
+ * control.
+ */
+export type PdfRuleKind = 'any' | 'number' | 'email';
+
+export const PDF_RULE_KINDS: readonly PdfRuleKind[] = ['any', 'number', 'email'];
+
+export interface PdfFieldRule {
+  kind: PdfRuleKind;
+  /** Shortest accepted length in characters (0 = no floor). */
+  min?: number;
+  /** Longest accepted length in characters (0 = no ceiling). */
+  max?: number;
+}
+
+export function isRuleKind(v: unknown): v is PdfRuleKind {
+  return typeof v === 'string' && PDF_RULE_KINDS.includes(v as PdfRuleKind);
+}
+
+/** The wire's `rule`, reduced to something drawable; `null` when there is none. */
+export function normalizeRule(raw: unknown): PdfFieldRule | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const r = raw as Record<string, unknown>;
+  const kind: PdfRuleKind = isRuleKind(r.kind) ? r.kind : 'any';
+  const out: PdfFieldRule = { kind };
+  const min = Math.trunc(Number(r.min));
+  const max = Math.trunc(Number(r.max));
+  if (Number.isFinite(min) && min > 0) out.min = min;
+  if (Number.isFinite(max) && max > 0) out.max = max;
+  // A bare `{kind: "any"}` with no bounds says nothing; treat it as no rule so
+  // it does not travel back as noise.
+  if (out.kind === 'any' && out.min === undefined && out.max === undefined) return null;
+  return out;
+}
+
+/** `inputmode` for the on-screen keyboard a rule wants. */
+export function ruleInputMode(rule: PdfFieldRule | null): 'text' | 'numeric' | 'email' {
+  if (!rule) return 'text';
+  if (rule.kind === 'number') return 'numeric';
+  if (rule.kind === 'email') return 'email';
+  return 'text';
+}
+
+/** The longest string the rule allows to be typed at all. */
+export function ruleMaxLength(rule: PdfFieldRule | null): number | undefined {
+  if (!rule) return undefined;
+  return rule.max && rule.max > 0 ? rule.max : undefined;
+}
+
+/**
+ * Type-as-you-go shaping. Returns what the field should hold after this
+ * keystroke — never an error: a rule refuses a CHARACTER here, and says why
+ * only in `ruleError` once there is something to judge.
+ */
+export function applyRule(raw: string, rule: PdfFieldRule | null): string {
+  let v = String(raw ?? '');
+  if (!rule) return v;
+  if (rule.kind === 'number') {
+    // Digits, one leading minus, one decimal separator — the separator kept
+    // as typed so a Turkish keyboard's comma is not silently rewritten.
+    const neg = v.startsWith('-');
+    let seen = false;
+    v = v
+      .split('')
+      .filter((ch) => {
+        if (ch >= '0' && ch <= '9') return true;
+        if ((ch === '.' || ch === ',') && !seen) {
+          seen = true;
+          return true;
+        }
+        return false;
+      })
+      .join('');
+    if (neg) v = `-${v}`;
+  } else if (rule.kind === 'email') {
+    v = v.replace(/\s+/g, '');
+  }
+  const max = ruleMaxLength(rule);
+  if (max && v.length > max) v = v.slice(0, max);
+  return v;
+}
+
+/** Codes `ruleErrorText` turns into words; `''` when the value is acceptable. */
+export type PdfRuleError = '' | 'number' | 'email' | 'min' | 'max';
+
+/** Is `value` acceptable under `rule`? An empty value is never wrong here — `required` is a separate question. */
+export function ruleError(value: unknown, rule: PdfFieldRule | null): PdfRuleError {
+  const v = typeof value === 'string' ? value.trim() : '';
+  if (!rule || v === '') return '';
+  if (rule.min && v.length < rule.min) return 'min';
+  if (rule.max && v.length > rule.max) return 'max';
+  if (rule.kind === 'number') return /^-?\d+([.,]\d+)?$/.test(v) ? '' : 'number';
+  if (rule.kind === 'email') return /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(v) ? '' : 'email';
+  return '';
+}
+