nixamp 0.6.0 → 0.6.1

package/dist/admin.d.ts

@@ -46,6 +46,19 @@ export interface AdminOptions {
 export declare function resolveTarget(argv: string[]): AdminOptions;
 /** Seconds as something a person reads at a glance. */
 export declare function since(ms: number): string;
+/**
+ * What a keypress contributes to a field being typed into.
+ *
+ * A paste is one event carrying the whole string, not a burst of single
+ * characters, so a handler that only accepted `key.length === 1` accepted
+ * nothing at all from a paste -- which is how you find you cannot put a URL in
+ * the box by any means except typing it out.
+ *
+ * The ambiguity is real and unavoidable: a pasted word of bare letters is
+ * indistinguishable from a key name, and loses. A URL or a path never is,
+ * because neither is spelled with letters alone.
+ */
+export declare function typed(key: string): string;
 export declare function bytes(value: number): string;
 export declare function admin(argv: string[]): Promise<void>;
 export interface View {

package/dist/admin.js

@@ -44,6 +44,31 @@ export function since(ms) {
         return `${hours}h ${minutes % 60}m`;
     return `${Math.floor(hours / 24)}d ${hours % 24}h`;
 }
+/**
+ * A key name rather than something somebody typed: "up", "f7", "ctrl+c".
+ * Letters and digits only, so anything with a colon or a slash in it is text.
+ */
+const NAMED_KEY = /^(?:[a-z]+\d*|(?:ctrl|alt|shift|meta)\+.+)$/;
+/**
+ * What a keypress contributes to a field being typed into.
+ *
+ * A paste is one event carrying the whole string, not a burst of single
+ * characters, so a handler that only accepted `key.length === 1` accepted
+ * nothing at all from a paste -- which is how you find you cannot put a URL in
+ * the box by any means except typing it out.
+ *
+ * The ambiguity is real and unavoidable: a pasted word of bare letters is
+ * indistinguishable from a key name, and loses. A URL or a path never is,
+ * because neither is spelled with letters alone.
+ */
+export function typed(key) {
+    if (key.length === 1)
+        return key >= " " && key !== "\u007f" ? key : "";
+    if (NAMED_KEY.test(key))
+        return "";
+    // A paste. Control characters and newlines are not part of an address.
+    return key.replace(/[\u0000-\u001f\u007f]/g, "");
+}
 export function bytes(value) {
     const units = ["B", "KiB", "MiB", "GiB"];
     let n = value;
@@ -109,9 +134,8 @@ export async function admin(argv) {
             }
             else if (key === "backspace")
                 restreaming = restreaming.slice(0, -1);
-            // A printable key is a character; everything else is a name like "f1".
-            else if (key.length === 1)
-                restreaming += key;
+            else
+                restreaming += typed(key);
             app.invalidate();
             return;
         }

package/dist/server.d.ts

@@ -239,6 +239,12 @@ export interface HandlerOptions {
      * imported so the handler stays a plain function of a request.
      */
     load: (source: string) => Promise<Track[]>;
+    /**
+     * The same source, with its tags, read without holding the event loop. Called
+     * after `load` and never awaited: the titles arrive into a player that is
+     * already playing.
+     */
+    tag?: (source: string) => Promise<Track[]>;
     /**
      * The public directory, on the instance that hosts one. Only nixamp.com
      * passes this; a nixamp on your laptop is a publisher, not a registry.

package/dist/server.js

@@ -1623,6 +1623,15 @@ export function createHandler(engine, options) {
                     return;
                 }
                 engine.replace(tracks, source);
+                // Names now, tags later, here as much as at startup: re-streaming a
+                // directory of five thousand files used to read every tag before it
+                // answered, with the event loop held the whole time.
+                if (options.tag) {
+                    void options
+                        .tag(source)
+                        .then((tagged) => engine.retag(tagged, source))
+                        .catch(() => { });
+                }
                 json(response, 200, engine.snapshot());
             }
             catch (error) {
@@ -2234,7 +2243,10 @@ export async function serve(argv, version = "0.1.0") {
         ffmpeg: tools.ffmpeg,
         ffprobe: tools.ffprobe,
         ...(tls ? { tls } : {}),
-        load: (next) => loadSource(tools, next),
+        // Untagged, so a directory of five thousand files answers at once; the
+        // tags follow through `tag` below.
+        load: (next) => loadSource(tools, next, false),
+        tag: (next) => loadTagged(tools, next),
         ...(directory ? { directory } : {}),
         ...(follows ? { follows, vapidPublicKey } : {}),
         ...(partyLine ? { partyLine } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/admin.ts

@@ -79,6 +79,31 @@ export function since(ms: number): string {
   return `${Math.floor(hours / 24)}d ${hours % 24}h`;
 }
 
+/**
+ * A key name rather than something somebody typed: "up", "f7", "ctrl+c".
+ * Letters and digits only, so anything with a colon or a slash in it is text.
+ */
+const NAMED_KEY = /^(?:[a-z]+\d*|(?:ctrl|alt|shift|meta)\+.+)$/;
+
+/**
+ * What a keypress contributes to a field being typed into.
+ *
+ * A paste is one event carrying the whole string, not a burst of single
+ * characters, so a handler that only accepted `key.length === 1` accepted
+ * nothing at all from a paste -- which is how you find you cannot put a URL in
+ * the box by any means except typing it out.
+ *
+ * The ambiguity is real and unavoidable: a pasted word of bare letters is
+ * indistinguishable from a key name, and loses. A URL or a path never is,
+ * because neither is spelled with letters alone.
+ */
+export function typed(key: string): string {
+  if (key.length === 1) return key >= " " && key !== "\u007f" ? key : "";
+  if (NAMED_KEY.test(key)) return "";
+  // A paste. Control characters and newlines are not part of an address.
+  return key.replace(/[\u0000-\u001f\u007f]/g, "");
+}
+
 export function bytes(value: number): string {
   const units = ["B", "KiB", "MiB", "GiB"];
   let n = value;
@@ -142,8 +167,7 @@ export async function admin(argv: string[]): Promise<void> {
         restreaming = "";
         if (url) void restream(target, headers, url).then(() => refresh());
       } else if (key === "backspace") restreaming = restreaming.slice(0, -1);
-      // A printable key is a character; everything else is a name like "f1".
-      else if (key.length === 1) restreaming += key;
+      else restreaming += typed(key);
       app.invalidate();
       return;
     }

package/src/server.ts

@@ -751,6 +751,12 @@ export interface HandlerOptions {
    * imported so the handler stays a plain function of a request.
    */
   load: (source: string) => Promise<Track[]>;
+  /**
+   * The same source, with its tags, read without holding the event loop. Called
+   * after `load` and never awaited: the titles arrive into a player that is
+   * already playing.
+   */
+  tag?: (source: string) => Promise<Track[]>;
   /**
    * The public directory, on the instance that hosts one. Only nixamp.com
    * passes this; a nixamp on your laptop is a publisher, not a registry.
@@ -1916,6 +1922,15 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           return;
         }
         engine.replace(tracks, source);
+        // Names now, tags later, here as much as at startup: re-streaming a
+        // directory of five thousand files used to read every tag before it
+        // answered, with the event loop held the whole time.
+        if (options.tag) {
+          void options
+            .tag(source)
+            .then((tagged) => engine.retag(tagged, source))
+            .catch(() => {});
+        }
         json(response, 200, engine.snapshot());
       } catch (error) {
         json(response, 422, { error: (error as Error).message.replace(/^nixamp: /, "") });
@@ -2577,7 +2592,10 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ffmpeg: tools.ffmpeg,
     ffprobe: tools.ffprobe,
     ...(tls ? { tls } : {}),
-    load: (next) => loadSource(tools, next),
+    // Untagged, so a directory of five thousand files answers at once; the
+    // tags follow through `tag` below.
+    load: (next) => loadSource(tools, next, false),
+    tag: (next) => loadTagged(tools, next),
     ...(directory ? { directory } : {}),
     ...(follows ? { follows, vapidPublicKey } : {}),
     ...(partyLine ? { partyLine } : {}),

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1788943887089";
+const CACHE = "nixamp-1788944263913";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",