cursedbelt-core 1.0.0 → 1.1.0

package/dist/core/file-tree/fileTreeModel.d.ts

@@ -259,6 +259,24 @@ export declare function resolveKeyboardMove({ nodes, rows, row, direction, locke
  * Empty for no target — a refusal has its own words and this must never carry a second "no".
  */
 export declare function describeDrop(nodes: readonly FileTreeNode[], drop: FileTreeDrop | null): string;
+/** The consumer's own words for the 🔒 access mark, per state. See {@link accessMarkCopy}. */
+export interface AccessMarkCopy {
+    private?: string;
+    locked?: string;
+}
+/**
+ * What the access mark's tooltip SAYS for a given access state.
+ *
+ * 🔴 The defaults speak collections' vocabulary — "hidden from a locked page" — because
+ * that is the app the mark was built for. The mark itself is generic and the words are
+ * not: the vault's protected folders wear the same padlock meaning "everything in here
+ * needs the master password", and a claim of hiddenness would be false there (the rows
+ * are visible; their SECRETS are sealed). So the words are an argument with a default,
+ * resolved here rather than inline, where they can be tested without simulating a hover.
+ *
+ * Empty string for `normal` — a row with no mark has nothing to say.
+ */
+export declare function accessMarkCopy(access: FileTreeAccess | undefined, copy?: AccessMarkCopy): string;
 /**
  * The next row whose name starts with `query`, searching from `fromIndex` and wrapping.
  *

package/dist/core/file-tree/fileTreeModel.js

@@ -268,6 +268,30 @@ export function describeDrop(nodes, drop) {
     const where = drop.kind === 'before' ? 'Above' : 'Below';
     return sibling ? `${where} ${sibling.name}` : `${where} this row`;
 }
+/**
+ * What the access mark's tooltip SAYS for a given access state.
+ *
+ * 🔴 The defaults speak collections' vocabulary — "hidden from a locked page" — because
+ * that is the app the mark was built for. The mark itself is generic and the words are
+ * not: the vault's protected folders wear the same padlock meaning "everything in here
+ * needs the master password", and a claim of hiddenness would be false there (the rows
+ * are visible; their SECRETS are sealed). So the words are an argument with a default,
+ * resolved here rather than inline, where they can be tested without simulating a hover.
+ *
+ * Empty string for `normal` — a row with no mark has nothing to say.
+ */
+export function accessMarkCopy(access, copy) {
+    if (access === 'locked')
+        return copy?.locked ?? 'Hidden — unlock to see what is in here';
+    if (access === 'private') {
+        // Deliberately "this or what is in it": a consumer sets `private` both for a row that
+        // is itself private and for a public folder holding private children (collections does
+        // exactly that), and a wording that claimed only the first would be false on half the
+        // rows it marks.
+        return copy?.private ?? 'Private — this, or something in it, is hidden from a locked page';
+    }
+    return '';
+}
 /**
  * The next row whose name starts with `query`, searching from `fromIndex` and wrapping.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-core",
-	"version": "1.0.0",
+	"version": "1.1.0",
 	"license": "ISC",
 	"type": "module",
 	"description": "Framework-agnostic core of the cursedbelt split \u2014 isomorphic domain logic. cwip below it, cursedbelt-server and cursedbelt (react) above it.",

package/src/core/file-tree/fileTreeModel.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 import {
+  accessMarkCopy,
   descendantIdsOf,
   type FileTreeDrop,
   type FileTreeNode,
@@ -460,3 +461,25 @@ describe('describeDrop', () => {
     expect(describeDrop(TREE, { kind: 'into', parentId: 'gone' })).toBe('Into this folder');
   });
 });
+
+describe('accessMarkCopy', () => {
+  test('defaults speak collections — hiddenness, per state', () => {
+    expect(accessMarkCopy('locked')).toBe('Hidden — unlock to see what is in here');
+    expect(accessMarkCopy('private')).toContain('hidden from a locked page');
+  });
+
+  test('🔴 a consumer with its own privacy vocabulary overrides the words', () => {
+    // The vault's protected folders wear the same padlock meaning "needs the master
+    // password" — a claim of hiddenness would be FALSE there (rows visible, secrets
+    // sealed), which is why the words are an argument and not a constant.
+    const copy = { private: 'Protected — everything in here needs the master password' };
+    expect(accessMarkCopy('private', copy)).toBe(copy.private);
+    // An override for one state leaves the other's default standing.
+    expect(accessMarkCopy('locked', copy)).toBe('Hidden — unlock to see what is in here');
+  });
+
+  test('normal (and absent) access has nothing to say', () => {
+    expect(accessMarkCopy('normal')).toBe('');
+    expect(accessMarkCopy(undefined)).toBe('');
+  });
+});

package/src/core/file-tree/fileTreeModel.ts

@@ -464,6 +464,39 @@ export function describeDrop(nodes: readonly FileTreeNode[], drop: FileTreeDrop
   return sibling ? `${where} ${sibling.name}` : `${where} this row`;
 }
 
+/** The consumer's own words for the 🔒 access mark, per state. See {@link accessMarkCopy}. */
+export interface AccessMarkCopy {
+  private?: string;
+  locked?: string;
+}
+
+/**
+ * What the access mark's tooltip SAYS for a given access state.
+ *
+ * 🔴 The defaults speak collections' vocabulary — "hidden from a locked page" — because
+ * that is the app the mark was built for. The mark itself is generic and the words are
+ * not: the vault's protected folders wear the same padlock meaning "everything in here
+ * needs the master password", and a claim of hiddenness would be false there (the rows
+ * are visible; their SECRETS are sealed). So the words are an argument with a default,
+ * resolved here rather than inline, where they can be tested without simulating a hover.
+ *
+ * Empty string for `normal` — a row with no mark has nothing to say.
+ */
+export function accessMarkCopy(
+  access: FileTreeAccess | undefined,
+  copy?: AccessMarkCopy,
+): string {
+  if (access === 'locked') return copy?.locked ?? 'Hidden — unlock to see what is in here';
+  if (access === 'private') {
+    // Deliberately "this or what is in it": a consumer sets `private` both for a row that
+    // is itself private and for a public folder holding private children (collections does
+    // exactly that), and a wording that claimed only the first would be false on half the
+    // rows it marks.
+    return copy?.private ?? 'Private — this, or something in it, is hidden from a locked page';
+  }
+  return '';
+}
+
 /**
  * The next row whose name starts with `query`, searching from `fromIndex` and wrapping.
  *