@domicile-desktop/system-apps 0.0.0-alpha-ddde2bfbbaad → 0.0.0-alpha-e1457b57e6b2

package/README.md

@@ -31,6 +31,7 @@ const editors = findApps(apps, "edit", 50);
 | `./find-apps`, `./bookmark` | The launcher's matching and ranking; bookmarks and their Zod schema. |
 | `./describe-apps` | Application IDs named and drawn by their entries, for a shell to say who asks. |
 | `./mime-apps` | A content type's default applications from every `mimeapps.list`, the desktop's own (`domicile-mimeapps.list`) first. |
+| `./openers` | The applications that open a file, its default first, and the argv each opens it with. The type comes from shared-mime-info's `mime/globs2`, by name. |
 | `./omit` | Desktop file IDs left out, as globs. |
 | `./app-icons` | Icon names resolved in `hicolor` and `pixmaps` to `data:` URLs (PNG, SVG, 128 KiB at most). |
 | `./favicon`, `./curl`, `./favicons` | A bookmark's icon: picked from the page, fetched with `curl`, kept and retried. |
@@ -40,7 +41,8 @@ const editors = findApps(apps, "edit", 50);
   unreadable file or directory is skipped, as the specs say.
 - `./curl` needs `curl` on the desktop's `PATH`. Domicile's Nix package adds
   it.
-- Launching stays with the shell: pass an entry's `command` to `spawn`.
+- Launching stays with the shell: pass an entry's `command`, or an
+  `openers` result's `command(app)`, to `spawn`.
 
 ## Test
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@cprussin/option-result": "^2.0.1",
-    "@domicile-desktop/sdk": "0.0.0-alpha-ddde2bfbbaad",
+    "@domicile-desktop/sdk": "0.0.0-alpha-e1457b57e6b2",
     "zod": "^4.5.4"
   },
   "description": "Installed applications and bookmarks for a Domicile shell's launcher, read through @domicile-desktop/sdk/system.",
@@ -24,7 +24,8 @@
     "./find-apps": "./src/find-apps.ts",
     "./installed": "./src/installed.ts",
     "./mime-apps": "./src/mime-apps.ts",
-    "./omit": "./src/omit.ts"
+    "./omit": "./src/omit.ts",
+    "./openers": "./src/openers.ts"
   },
   "files": [
     "src/**",
@@ -47,5 +48,5 @@
     "test:unit": "bun test"
   },
   "type": "module",
-  "version": "0.0.0-alpha-ddde2bfbbaad"
+  "version": "0.0.0-alpha-e1457b57e6b2"
 }

package/src/content-type.ts

@@ -0,0 +1,73 @@
+// A file's content type, by name, from shared-mime-info's `mime/globs2`. See
+// https://specifications.freedesktop.org/shared-mime-info-spec/latest/.
+
+import type { Option, Result } from "@cprussin/option-result";
+import { None, Ok, Some } from "@cprussin/option-result";
+import type { System, SystemError } from "@domicile-desktop/sdk/system";
+import { FileType } from "@domicile-desktop/sdk/system";
+
+import { globOf } from "./glob";
+import { allOk, orAbsent } from "./results";
+
+/** The type shared-mime-info gives every directory. */
+const DIRECTORY = "inode/directory";
+
+/** One `globs2` line. */
+type Glob = { weight: number; type: string; pattern: string; glob: RegExp };
+
+/**
+ * `path`'s content type, or nothing when no glob matches its name.
+ *
+ * Matches the name only; contents are not sniffed. Reads `mime/globs2` under
+ * each of `dataDirs`, missing ones skipped. The heaviest match wins, then the
+ * longest pattern, then the earliest directory.
+ */
+export const contentTypeOf = async (
+  system: System,
+  dataDirs: readonly string[],
+  path: string,
+): Promise<Result<Option<string>, SystemError>> =>
+  (await system.stat(path)).andThenAsync(async ({ fileType }) =>
+    fileType === FileType.Directory
+      ? Ok<Option<string>, SystemError>(Some(DIRECTORY))
+      : allOk(
+          await Promise.all(
+            dataDirs.map(async (dir) =>
+              orAbsent(await system.readTextFile(`${dir}/mime/globs2`), "").map(
+                globsIn,
+              ),
+            ),
+          ),
+        ).map((globs) => matching(globs.flat(), nameOf(path))),
+  );
+
+/** The type of the best glob matching `name`. */
+const matching = (globs: readonly Glob[], name: string): Option<string> => {
+  const best = globs
+    .filter(({ glob }) => glob.test(name))
+    .toSorted(
+      (a, b) => b.weight - a.weight || b.pattern.length - a.pattern.length,
+    )[0];
+  return best === undefined ? None() : Some(best.type);
+};
+
+/** The globs `text` lists: `weight:type:glob[:flags]`. */
+const globsIn = (text: string): Glob[] =>
+  text
+    .split("\n")
+    .filter((line) => line !== "" && !line.startsWith("#"))
+    .map((line) => {
+      const [weight = "", type = "", pattern = "", flags = ""] =
+        line.split(":");
+      const glob = globOf(pattern);
+      return {
+        glob: flags.split(",").includes("cs")
+          ? glob
+          : new RegExp(glob.source, `${glob.flags}i`),
+        pattern,
+        type,
+        weight: Number(weight),
+      };
+    });
+
+const nameOf = (path: string): string => path.slice(path.lastIndexOf("/") + 1);

package/src/desktop-entry.ts

@@ -19,6 +19,10 @@ export type DesktopEntry = {
   comment: string;
   /** The argv it runs. */
   command: readonly string[];
+  /** `Exec` as written, for `commandOf` to open a file with. */
+  exec: string;
+  /** `MimeType`: the content types it opens. */
+  mimeTypes: readonly string[];
   /** `Name`, `GenericName` and `Keywords`, in lower case, for `findApps`. */
   words: string;
   /** `Icon`: a theme name or an absolute path. See `./app-icons`. */
@@ -52,8 +56,12 @@ export const parseDesktopEntry = (
     : commandOf(exec).map((command) => ({
         command,
         comment: unescaped(keys.get("Comment") ?? ""),
+        exec,
         icon: optional(keys.get("Icon")),
         id,
+        mimeTypes: (keys.get("MimeType") ?? "")
+          .split(";")
+          .filter((type) => type !== ""),
         name: unescaped(name),
         preview: optional(keys.get("X-Domicile-Preview")),
         words: [name, keys.get("GenericName") ?? "", keys.get("Keywords") ?? ""]

package/src/exec.ts

@@ -5,15 +5,20 @@ import { None, Some } from "@cprussin/option-result";
 
 import { unescaped } from "./escapes";
 
+/** The field codes for files and URLs. A local file may stand for a URL. */
+const FILE_CODES = new Set(["f", "F", "u", "U"]);
+
 /**
- * `exec` as argv, or nothing if it is malformed or empty.
+ * `exec` as argv opening `file`, or nothing if it is malformed or empty.
  *
- * Unescapes strings, then quoting, in the spec's order. Drops field codes,
- * since a launcher passes no files, URLs or icon, along with any argument
- * that was only a field code.
+ * Unescapes strings, then quoting, in the spec's order. Puts `file` in place
+ * of each file or URL field code, or after the last argument when there is
+ * none. Drops every other field code, along with any argument that was only a
+ * field code.
  */
-export const commandOf = (exec: string): Option<string[]> => {
+export const commandOf = (exec: string, file?: string): Option<string[]> => {
   const words: string[] = [];
+  let placed = false;
   let word = "";
   let quoted = false;
   // Whether the previous character was a `\` inside quotes, or a `%`.
@@ -24,7 +29,8 @@ export const commandOf = (exec: string): Option<string[]> => {
       word += char;
       escaping = false;
     } else if (fieldCode) {
-      word += char === "%" ? "%" : "";
+      word += expanded(char, file);
+      placed ||= file !== undefined && FILE_CODES.has(char);
       fieldCode = false;
     } else if (char === '"') {
       quoted = !quoted;
@@ -40,5 +46,15 @@ export const commandOf = (exec: string): Option<string[]> => {
     }
   }
   words.push(...(word === "" ? [] : [word]));
+  words.push(...(file === undefined || placed ? [] : [file]));
   return quoted || words.length === 0 ? None() : Some(words);
 };
+
+/** What field code `code` stands for when opening `file`. */
+const expanded = (code: string, file: string | undefined): string => {
+  if (file !== undefined && FILE_CODES.has(code)) {
+    return file;
+  } else {
+    return code === "%" ? "%" : "";
+  }
+};

package/src/glob.ts

@@ -0,0 +1,33 @@
+// Shell-style globs, as the XDG specs use them.
+
+/**
+ * `pattern` as an anchored regular expression: `*` matches any run, `?` one
+ * character and `[…]` one of a set. Throws on a pattern that is not a glob.
+ */
+export const globOf = (pattern: string): RegExp => {
+  const parts = pattern.match(/\[[^\]]*\]|\*|\?|\[|[^*?[]+/g) ?? [];
+  return new RegExp(
+    `^${parts
+      .map((part) => {
+        switch (part) {
+          case "*": {
+            return ".*";
+          }
+          case "?": {
+            return ".";
+          }
+          case "[": {
+            throw new Error(
+              `\`${pattern}\` is not a glob: \`[\` is not closed`,
+            );
+          }
+          default: {
+            // A `[…]` set reads the same as a regular expression's.
+            return part.startsWith("[") ? part : RegExp.escape(part);
+          }
+        }
+      })
+      .join("")}$`,
+    "s",
+  );
+};

package/src/omit.ts

@@ -1,5 +1,7 @@
 // Which desktop file IDs a launcher leaves out, as globs.
 
+import { globOf } from "./glob";
+
 /**
  * Whether a desktop file ID is left out, per `patterns`.
  *
@@ -20,32 +22,3 @@ export const omitting = (
     return last !== undefined && !last.keeps;
   };
 };
-
-/** `pattern` as an anchored regular expression. */
-const globOf = (pattern: string): RegExp => {
-  const parts = pattern.match(/\[[^\]]*\]|\*|\?|\[|[^*?[]+/g) ?? [];
-  return new RegExp(
-    `^${parts
-      .map((part) => {
-        switch (part) {
-          case "*": {
-            return ".*";
-          }
-          case "?": {
-            return ".";
-          }
-          case "[": {
-            throw new Error(
-              `\`${pattern}\` is not a glob: \`[\` is not closed`,
-            );
-          }
-          default: {
-            // A `[…]` set reads the same as a regular expression's.
-            return part.startsWith("[") ? part : RegExp.escape(part);
-          }
-        }
-      })
-      .join("")}$`,
-    "s",
-  );
-};

package/src/openers.ts

@@ -0,0 +1,99 @@
+// The applications that open a file, its default first, and the argv each
+// opens it with.
+
+import type { Option, Result } from "@cprussin/option-result";
+import { Ok } from "@cprussin/option-result";
+import type { System, SystemError } from "@domicile-desktop/sdk/system";
+
+import { contentTypeOf } from "./content-type";
+import { dataDirs } from "./data-dirs";
+import type { DesktopEntry } from "./desktop-entry";
+import { desktopEnvironment, setVariable } from "./environment";
+import { commandOf } from "./exec";
+import { installedApps } from "./installed";
+import { defaultApps } from "./mime-apps";
+
+/** What can open a file. */
+export type Openers = {
+  /** The file's content type, by name. Nothing when no glob matches. */
+  contentType: Option<string>;
+  /**
+   * The installed applications for the type: its defaults from
+   * `mimeapps.list` in their order (see `./mime-apps`), then the rest whose
+   * `MimeType` lists it, by name. The first is the one to open it with.
+   */
+  apps: DesktopEntry[];
+  /** The argv that opens the file with `app`. */
+  command: (app: DesktopEntry) => string[];
+};
+
+/**
+ * What can open `path`: relative to home, as every system call's path is, or
+ * absolute.
+ *
+ * Only `MimeType` and the defaults are read: aliases, subclasses and
+ * `mimeapps.list`'s added and removed associations are not. A launcher falls
+ * back to `xdg-open` when this offers nothing.
+ */
+export const openers = async (
+  system: System,
+  path: string,
+): Promise<Result<Openers, SystemError>> =>
+  (await desktopEnvironment(system)).andThenAsync(async (variables) => {
+    const file = path.startsWith("/") ? path : `${homeOf(variables)}/${path}`;
+    return (await dataDirs(system)).andThenAsync(async (dirs) =>
+      (await contentTypeOf(system, dirs, path)).andThenAsync(
+        async (contentType) =>
+          (
+            await contentType.match({
+              None: () => Promise.resolve(Ok<DesktopEntry[], SystemError>([])),
+              Some: (type) => appsFor(system, dirs, type),
+            })
+          ).map((apps) => ({
+            apps,
+            command: (app: DesktopEntry) => commandFor(app, file),
+            contentType,
+          })),
+      ),
+    );
+  });
+
+/** The installed applications for `contentType`, in `Openers.apps`'s order. */
+const appsFor = async (
+  system: System,
+  dirs: readonly string[],
+  contentType: string,
+): Promise<Result<DesktopEntry[], SystemError>> =>
+  (await installedApps(system, dirs)).andThenAsync(async (installed) =>
+    (await defaultApps(system, contentType)).map((defaults) => {
+      const byId = new Map(installed.map((app) => [app.id, app]));
+      const first = [...new Set(defaults)].flatMap((id) => {
+        const app = byId.get(id);
+        return app === undefined ? [] : [app];
+      });
+      const rest = installed
+        .filter(
+          (app) => app.mimeTypes.includes(contentType) && !first.includes(app),
+        )
+        .toSorted((a, b) => a.name.localeCompare(b.name));
+      return [...first, ...rest];
+    }),
+  );
+
+const homeOf = (variables: ReadonlyMap<string, string>): string => {
+  const home = setVariable(variables, "HOME");
+  if (home === undefined) {
+    throw new Error("the desktop has no HOME to open a file under");
+  } else {
+    return home;
+  }
+};
+
+/** `app`'s argv for `file`. It was read once already, so it reads again. */
+const commandFor = (app: DesktopEntry, file: string): string[] =>
+  commandOf(app.exec, file).match({
+    None: () => {
+      throw new Error(`${app.id}'s Exec could not be read again`);
+    },
+    Some: (command) => command,
+  });