@3sln/trove 0.0.7 → 0.0.9

package/packages/web/src/bl/match.js

@@ -0,0 +1,71 @@
+// Ranking what someone typed against a list of things.
+//
+// There were two of these, for one question. The command palette scored per matched
+// character and added 10 for a contiguous substring; the launcher's `!` mode returned
+// `1000 - index` for a substring and a flat 1 otherwise. So typing the same three letters
+// ranked the same commands differently depending on which way you had reached them — and
+// the launcher's version could not distinguish two commands that both merely contained the
+// letters, because every non-substring match scored exactly 1.
+//
+// Neither was wrong so much as unaware of the other. Ranking is a decision about the
+// drive's own vocabulary, so it belongs here, once.
+
+/**
+ * How well `hay` matches `term`. 0 means no match at all.
+ *
+ * Subsequence first — the letters must appear in order, which is what makes "cmp" find
+ * "Command Palette". Then three things push a better match up:
+ *
+ *   - a contiguous substring beats scattered letters, by a lot
+ *   - an earlier hit beats a later one, so typing "set" prefers "Settings" to "Reset"
+ *   - adjacent letters beat gaps, which is the difference between "op" matching "Open" and
+ *     matching "Only Photographs"
+ *
+ * @param {string} hay already lowercased
+ * @param {string} term already lowercased and trimmed
+ */
+export function matchScore(hay, term) {
+  if (!term) return 1;
+  let score = 0;
+  let from = 0;
+  for (const ch of term) {
+    const at = hay.indexOf(ch, from);
+    if (at < 0) return 0; // not a subsequence — not a match
+    score += at === from ? 3 : 1; // adjacency is worth more than mere presence
+    from = at + 1;
+  }
+  const sub = hay.indexOf(term);
+  if (sub >= 0) {
+    // A contiguous run is the strongest signal there is, and the earlier it starts the
+    // more likely it is what was meant.
+    score += 100 - Math.min(50, sub);
+  }
+  return score;
+}
+
+/**
+ * Commands matching `term`, best first.
+ *
+ * The haystack is "category title" because someone typing "view" means the View category
+ * as readily as they mean a command with View in its name.
+ *
+ * @param {Array<{id: string, title: string, category?: string}>} commands
+ * @param {string} term what was typed, without any leading `!`
+ * @param {number} [limit]
+ */
+export function rankCommands(commands, term, limit = 60) {
+  const q = (term || '').trim().toLowerCase();
+  const all = commands || [];
+  if (!q) return all.slice(0, limit);
+  const scored = [];
+  for (const c of all) {
+    const s = matchScore(`${c.category || ''} ${c.title}`.toLowerCase(), q);
+    if (s > 0) scored.push([s, c]);
+  }
+  // Ties break by title, so a list that cannot decide is at least stable rather than
+  // ordered by whatever registered first.
+  return scored
+    .sort((a, b) => b[0] - a[0] || String(a[1].title).localeCompare(String(b[1].title)))
+    .slice(0, limit)
+    .map(([, c]) => c);
+}

package/packages/web/src/bl/mentions.js

@@ -0,0 +1,39 @@
+// The `@someone` syntax in a comment body.
+//
+// A sibling of bl/tagQuery.js, which parses the `#tag` syntax — and it sat in the social
+// COMPONENT instead, a regex splitting a text format mid-render. Parsing the drive's own
+// notation is business-layer work wherever it happens to be displayed, and having half of
+// it here and half of it in a view is how the two end up disagreeing about what a name
+// may contain.
+//
+// Two spellings, because they arrive from different places. The resolved form
+// `@[Display Name](user-id)` is what the server writes once it knows who was meant; the
+// bare form `@handle` is what someone types before anything has resolved it.
+
+const MENTION = /@\[([^\]]+)\]\(([^)]+)\)|(?:^|\s)@([a-zA-Z0-9._@-]{2,})/g;
+
+/**
+ * Split a comment body into runs of plain text and mentions.
+ *
+ * @param {string} body
+ * @returns {Array<{type: 'text', value: string} | {type: 'mention', name: string, id: string|null}>}
+ */
+export function parseMentions(body) {
+  const text = body || '';
+  const out = [];
+  const re = new RegExp(MENTION.source, 'g'); // own lastIndex — the module-level one is shared
+  let last = 0;
+  let m;
+  while ((m = re.exec(text))) {
+    // The bare form's match deliberately includes the space in front of the `@`, so that
+    // "a@b" is an address rather than a mention. That leading space belongs to the text
+    // run, not to the mention.
+    const bare = !!m[3];
+    const start = m.index + (bare && m[0].startsWith(' ') ? 1 : 0);
+    if (start > last) out.push({ type: 'text', value: text.slice(last, start) });
+    out.push({ type: 'mention', name: m[1] || m[3], id: m[2] || null });
+    last = re.lastIndex;
+  }
+  if (last < text.length) out.push({ type: 'text', value: text.slice(last) });
+  return out;
+}

package/packages/web/src/bl/offline.js

@@ -69,10 +69,6 @@ export class OfflineService {
     await this.platform.plugins?.setOnline?.(false);
   }
 
-  isPinned(id) {
-    return this.state.pins.some((p) => p.id === id);
-  }
-
   // --- pinning ---------------------------------------------------------------
 
   async pin(node) {

package/packages/web/src/bl/openers.js

@@ -7,12 +7,49 @@
 // Preferences live in settings under `openers.associations`: a map from a *type key*
 // (an extension like ".pdf", an exact mime, or a "type/*" wildcard) to an opener id.
 
+import { selectorMatches } from '@3sln/trove/core/util.js';
 import { extOf } from './fileType.js';
 
-const ASSOC_KEY = 'openers.associations';
+export const ASSOC_KEY = 'openers.associations';
 
 export { extOf };
 
+/**
+ * One opener as the chooser and the switcher need to see it: what it is called, what it
+ * claims, and where it came from.
+ *
+ * `source` is resolved here because it needs the plugin host to answer, which a component
+ * has no business holding. `match` stays so the selector can be applied later, by
+ * `openersFor`, against a node the caller already has.
+ *
+ * No `component`, only because nothing on this path renders — both callers are picking
+ * between openers, not drawing with one. (A renderer would be fine to pass: it is a pure
+ * vnode builder. See the `views` query, which does exactly that.)
+ */
+export function describeOpener(opener, plugins) {
+  return {
+    id: opener.id,
+    title: opener.title ?? opener.name ?? opener.id,
+    match: opener.match ?? null,
+    priority: opener.priority ?? 0,
+    pluginId: opener.pluginId ?? null,
+    source: opener.pluginId
+      ? (plugins?.plugins?.get(opener.pluginId)?.manifest?.displayName || opener.pluginId)
+      : 'Built-in',
+  };
+}
+
+/**
+ * Which of these openers claim this node, best first.
+ *
+ * Pure, and deliberately so — see the `openers` query. Every reactive decision (when-clause,
+ * plugin health, priority order) has already been made; all that is left is running a
+ * selector over a file, which needs nothing but its two arguments.
+ */
+export function openersFor(openers, node) {
+  return (openers || []).filter((o) => selectorMatches(o.match, node));
+}
+
 /** The canonical type key we remember a choice under: prefer extension, else mime. */
 export function typeKeyFor(node) {
   return extOf(node) || node?.contentType || '';
@@ -26,46 +63,41 @@ export function typeLabelFor(node) {
   return mime ? `${mime} files` : 'this file type';
 }
 
-/** All openers that can handle this node right now (selector + when + availability),
- *  best (highest priority) first. */
-export function availableOpeners(platform, node) {
-  const evaluate = (w) => platform.context.evaluate(w);
-  const isAvailable = (o) => platform.plugins.isAvailable(o);
-  return platform.contributions
+/**
+ * All openers that can handle this node right now (selector + when + availability),
+ * best (highest priority) first — for an ACTION, which holds the resources to ask.
+ *
+ * The render layer gets the same answer the other way round: the `openers` query resolves
+ * when/availability, `openersFor` applies the selector. Both end at `describeOpener`, so
+ * the opener-chooser dialog looks the same whichever side opened it.
+ */
+export function availableOpeners(r, node) {
+  return r.contributions
     .openersFor(node)
-    .filter((o) => (!o.when || evaluate(o.when)) && isAvailable(o))
-    .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    .filter((o) => (!o.when || r.context.evaluate(o.when)) && r.plugins.isAvailable(o))
+    .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
+    .map((o) => describeOpener(o, r.plugins));
 }
 
 /** The remembered opener id for a node's type (ext → exact mime → type/* ), or null. */
-export function rememberedOpenerId(platform, node) {
-  const assoc = platform.settings.get(ASSOC_KEY) || {};
+export function rememberedOpenerId(r, node) {
+  const assoc = r.settings.get(ASSOC_KEY) || {};
   const ext = extOf(node);
   const mime = node?.contentType || '';
   const wild = mime.includes('/') ? `${mime.slice(0, mime.indexOf('/') + 1)}*` : '';
   return (ext && assoc[ext]) || (mime && assoc[mime]) || (wild && assoc[wild]) || null;
 }
 
-/** Remember (or, with a null openerId, forget) the opener for a type key. */
-export function rememberOpener(platform, typeKey, openerId) {
-  if (!typeKey) return;
-  const assoc = { ...(platform.settings.get(ASSOC_KEY) || {}) };
-  if (openerId) assoc[typeKey] = openerId;
-  else delete assoc[typeKey];
-  platform.settings.set(ASSOC_KEY, assoc);
-}
-
-/** The saved associations as a list, for the Settings UI. */
-export function listAssociations(platform) {
-  const assoc = platform.settings.get(ASSOC_KEY) || {};
-  return Object.entries(assoc).map(([typeKey, openerId]) => {
-    const opener = platform.contributions.get(openerId);
-    return { typeKey, openerId, openerTitle: opener?.title || openerId, missing: !opener };
-  });
-}
-
-/** A short source label for an opener ("Built-in" or the plugin's name). */
-export function openerSource(platform, opener) {
-  if (!opener?.pluginId) return 'Built-in';
-  return platform.plugins.plugins.get(opener.pluginId)?.manifest?.displayName || opener.pluginId;
+/**
+ * The associations with one type key changed, or removed with a null openerId.
+ *
+ * Returns the next map rather than writing it: the write is `RememberOpenerAction`'s, and
+ * keeping the arithmetic separate from the effect is what lets both the settings screen and
+ * the opener chooser reach it without either touching `settings`.
+ */
+export function withAssociation(assoc, typeKey, openerId) {
+  const next = { ...(assoc || {}) };
+  if (openerId) next[typeKey] = openerId;
+  else delete next[typeKey];
+  return next;
 }

package/packages/web/src/bl/pluginInstall.js

@@ -1,59 +1,80 @@
 // Install flow: turn an uploaded .zip or a URL into a parsed package, assess its
 // trust (signature + domain verification), and present the pre-install review so
 // the user can make an informed decision before any plugin code runs.
+//
+// Takes the four resources it actually needs rather than the whole `app`. That is what let
+// the last two actions stop leasing `app` — and a lease that names notifications, plugins,
+// workbench and social says what an install touches, where `app` said nothing at all.
 
 import { parsePackage, fetchPackage, reviewSummary, displayName } from '../platform/pluginPackage.js';
 import { pluginId } from '@3sln/trove/core/plugins/identity.js';
+import { installPolicyFor } from './trust.js';
 
-export async function beginInstallFromFile(app, file) {
+/** @typedef {{notifications: object, overlay: object, plugins: object, social: object, workbench: object}} InstallResources */
+
+/** @param {InstallResources} r */
+export async function beginInstallFromFile(r, file) {
   try {
     const bytes = new Uint8Array(await file.arrayBuffer());
-    await review(app, parsePackage(bytes));
+    await review(r, parsePackage(bytes));
   } catch (err) {
-    app.platform.notifications.error(`Couldn't read the plugin: ${err.message}`);
+    r.notifications.error(`Couldn't read the plugin: ${err.message}`);
   }
 }
 
-export async function beginInstallFromUrl(app, url) {
+/** @param {InstallResources} r */
+export async function beginInstallFromUrl(r, url) {
   try {
     const pkg = await fetchPackage(url, (u, o) => fetch(u, o));
-    await review(app, pkg);
+    await review(r, pkg);
   } catch (err) {
-    app.platform.notifications.error(`Couldn't fetch the plugin: ${err.message}`);
+    r.notifications.error(`Couldn't fetch the plugin: ${err.message}`);
   }
 }
 
-async function review(app, pkg) {
+async function review(r, pkg) {
   const label = displayName(pkg.manifest);
-  if (app.platform.plugins.plugins.has(pluginId(pkg.manifest))) {
-    app.platform.notifications.warn(`“${label}” is already installed.`);
+  if (r.plugins.plugins.has(pluginId(pkg.manifest))) {
+    r.notifications.warn(`“${label}” is already installed.`);
     return;
   }
   // Trust assessment can hit the network (domain assetlinks); do it before review.
   let trust = { status: 'unverified' };
   try {
-    trust = await app.platform.plugins.assessTrust(pkg);
+    trust = await r.plugins.assessTrust(pkg);
   } catch { /* offline / unreachable */ }
+
+  // A tampered package is refused here rather than presented with a warning. The review
+  // dialog exists to let someone weigh what a plugin asks for against who is asking; a
+  // signature that does not match its contents means the "who" is unknown and the contents
+  // are not what was signed, so there is nothing to weigh. See installPolicyFor.
+  const policy = installPolicyFor(trust);
+  if (!policy.allowed) {
+    r.notifications.error(`“${label}” was not installed. ${policy.detail}`, { sticky: true });
+    return;
+  }
+
   const summary = reviewSummary(pkg, trust);
-  app.platform.workbench.showDialog({
+  r.overlay.set({ dialog: {
     kind: 'plugin-review',
     summary,
-    isAdmin: !!app.social.state.admin,
+    policy,
+    isAdmin: !!r.social.state.admin,
     onInstall: async (grants) => {
-      app.platform.workbench.closeDialog();
+      r.overlay.set({ dialog: null });
       // Account installs upload the package + run a handshake that can take a while —
       // switch to the plugins view (which shows the plugin's loading state) and hold a
       // sticky "Installing…" toast so the user isn't left staring at nothing.
-      app.platform.workbench.setActivity('plugins');
-      const pending = app.platform.notifications.info(`Installing “${label}”…`, { sticky: true });
+      r.workbench.set({ activity: 'plugins', sidebarVisible: true });
+      const pending = r.notifications.info(`Installing “${label}”…`, { sticky: true });
       try {
-        await app.platform.plugins.install(pkg, { grants, trust });
-        app.platform.notifications.dismiss(pending);
-        app.platform.notifications.success(`Installed “${label}”`);
+        await r.plugins.install(pkg, { grants, trust });
+        r.notifications.dismiss(pending);
+        r.notifications.success(`Installed “${label}”`);
       } catch (err) {
-        app.platform.notifications.dismiss(pending);
-        app.platform.notifications.error(`Install failed: ${err.message}`);
+        r.notifications.dismiss(pending);
+        r.notifications.error(`Install failed: ${err.message}`);
       }
     },
-  });
+  } });
 }