@domicile-desktop/system-apps 0.0.0-alpha-a330bf5f3aae

package/src/omit.ts

@@ -0,0 +1,51 @@
+// Which desktop file IDs a launcher leaves out, as globs.
+
+/**
+ * Whether a desktop file ID is left out, per `patterns`.
+ *
+ * Each pattern is a glob: `*` matches any run, `?` one character and `[…]`
+ * one of a set. A pattern starting with `!` takes an ID back, and the last
+ * matching pattern wins, so `["*", "!launcher-*"]` keeps only IDs starting
+ * with `launcher-`. Throws on a pattern that is not a glob.
+ */
+export const omitting = (
+  patterns: readonly string[],
+): ((id: string) => boolean) => {
+  const rules = patterns.map((pattern) => {
+    const keeps = pattern.startsWith("!");
+    return { glob: globOf(keeps ? pattern.slice(1) : pattern), keeps };
+  });
+  return (id) => {
+    const last = rules.findLast(({ glob }) => glob.test(id));
+    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/ranked.ts

@@ -0,0 +1,60 @@
+// The launcher's matching rule, shared by applications and bookmarks so their
+// rows agree.
+
+/** How to match and order one kind of row. */
+export type Ranking<T> = {
+  /** The text every query word must appear in, in lower case. */
+  words: (item: T) => string;
+  name: (item: T) => string;
+  /** Orders equal names, so the order does not depend on a listing's. */
+  tieBreak: (item: T) => string;
+};
+
+/**
+ * Up to `limit` of `items` matching `query`, best first.
+ *
+ * Every query word must appear, case-insensitively, in the item's words.
+ * Names that start with the query rank first, then sort by name.
+ */
+export const ranked = <T>(
+  items: readonly T[],
+  query: string,
+  limit: number,
+  ranking: Ranking<T>,
+): T[] => {
+  const typed = query.trim().toLowerCase();
+  const words = typed.split(/\s+/).filter((word) => word !== "");
+  return items
+    .filter((item) => {
+      const text = ranking.words(item);
+      return words.every((word) => text.includes(word));
+    })
+    .map((item) => {
+      const name = ranking.name(item).toLowerCase();
+      return {
+        item,
+        key: [
+          name.startsWith(typed) ? 0 : 1,
+          name,
+          ranking.tieBreak(item),
+        ] as const,
+      };
+    })
+    .toSorted((a, b) => compared(a.key, b.key))
+    .slice(0, limit)
+    .map(({ item }) => item);
+};
+
+/** Compares keys element by element, strings by UTF-16 code unit. */
+const compared = (
+  a: readonly [number, string, string],
+  b: readonly [number, string, string],
+): number => a[0] - b[0] || byCodeUnit(a[1], b[1]) || byCodeUnit(a[2], b[2]);
+
+const byCodeUnit = (a: string, b: string): number => {
+  if (a < b) {
+    return -1;
+  } else {
+    return a > b ? 1 : 0;
+  }
+};

package/src/results.ts

@@ -0,0 +1,46 @@
+// Combining the `Result`s of system calls made side by side.
+
+import type { Result } from "@cprussin/option-result";
+import { Ok } from "@cprussin/option-result";
+import type { SystemError } from "@domicile-desktop/sdk/system";
+import { SystemErrorKind } from "@domicile-desktop/sdk/system";
+
+/** Every value, or the first error. */
+export const allOk = <
+  T extends NonNullable<unknown>,
+  E extends NonNullable<unknown>,
+>(
+  results: readonly Result<T, E>[],
+): Result<T[], E> =>
+  results.reduce<Result<T[], E>>(
+    (all, each) =>
+      all.andThen((values) => each.map((value) => [...values, value])),
+    Ok([]),
+  );
+
+/**
+ * `result`, with `absent` in place of an error that means the path is not
+ * there to read: missing, of the other kind, or unreadable. The spec says to
+ * skip those. Any other error, such as a locked desktop, is kept.
+ */
+export const orAbsent = <T extends NonNullable<unknown>>(
+  result: Result<T, SystemError>,
+  absent: T,
+): Result<T, SystemError> =>
+  result.orElse((error) => {
+    switch (error.kind) {
+      case SystemErrorKind.NotFound:
+      case SystemErrorKind.NotADirectory:
+      case SystemErrorKind.IsADirectory:
+      case SystemErrorKind.PermissionDenied: {
+        return Ok(absent);
+      }
+      case SystemErrorKind.AlreadyExists:
+      case SystemErrorKind.InvalidInput:
+      case SystemErrorKind.Locked:
+      case SystemErrorKind.Dbus:
+      case SystemErrorKind.Other: {
+        return result;
+      }
+    }
+  });