@storyteller-platform/audiobook 0.1.0 → 0.3.0

package/dist/entry.cjs

@@ -21,34 +21,127 @@ __export(entry_exports, {
   AudiobookEntry: () => AudiobookEntry
 });
 module.exports = __toCommonJS(entry_exports);
-var import_zip = require("@zip.js/zip.js");
-var import_node_taglib_sharp = require("node-taglib-sharp");
-var import_base = require("./base.cjs");
-var import_Uint8ArrayFileAbstraction = require("./taglib/Uint8ArrayFileAbstraction.cjs");
-class AudiobookEntry extends import_base.BaseAudiobookEntry {
-  constructor(entry) {
-    super();
-    this.entry = entry;
-    this.filename = entry.filename;
-  }
-  filename;
-  file = null;
-  async readData() {
-    if ("data" in this.entry) {
-      return this.entry.data;
-    }
-    const writer = new import_zip.Uint8ArrayWriter();
-    return await this.entry.getData(writer);
-  }
-  async getData() {
-    const file = await this.getFile();
-    return file.fileAbstraction.data;
-  }
-  async createFile() {
-    const data = await this.readData();
-    return import_node_taglib_sharp.File.createFromAbstraction(
-      new import_Uint8ArrayFileAbstraction.Uint8ArrayFileAbstraction(this.filename, data)
-    );
+var import_ffmpeg = require("./ffmpeg.cjs");
+var import_mime = require("./mime.cjs");
+function splitNames(names) {
+  if (!names) return [];
+  return names.split(/[;,/]/).map((name) => name.trim());
+}
+class AudiobookEntry {
+  constructor(filename) {
+    this.filename = filename;
+  }
+  info = null;
+  async getInfo() {
+    this.info ??= await (0, import_ffmpeg.getTrackMetadata)(this.filename);
+    return this.info;
+  }
+  async getMetadataTags() {
+    const info = await this.getInfo();
+    return info.tags;
+  }
+  async getTitle() {
+    const tags = await this.getMetadataTags();
+    return tags.album ?? tags.title ?? null;
+  }
+  async setTitle(title) {
+    const tags = await this.getMetadataTags();
+    tags.album = title;
+  }
+  async getTrackTitle() {
+    const tags = await this.getMetadataTags();
+    return tags.title ?? null;
+  }
+  async setTrackTitle(trackTitle) {
+    const tags = await this.getMetadataTags();
+    tags.title = trackTitle;
+  }
+  async getSubtitle() {
+    const tags = await this.getMetadataTags();
+    return tags.subtitle ?? null;
+  }
+  async setSubtitle(subtitle) {
+    const tags = await this.getMetadataTags();
+    tags.subtitle = subtitle;
+  }
+  async getDescription() {
+    const tags = await this.getMetadataTags();
+    return tags.description ?? tags.comment ?? null;
+  }
+  async setDescription(description) {
+    const tags = await this.getMetadataTags();
+    tags.description = description;
+    tags.comment = description;
+  }
+  async getAuthors() {
+    const tags = await this.getMetadataTags();
+    return splitNames(tags.albumArtist ?? tags.artist);
+  }
+  async setAuthors(authors) {
+    const tags = await this.getMetadataTags();
+    tags.artist = authors.join(";");
+    tags.albumArtist = authors.join(";");
+  }
+  async getNarrators() {
+    const tags = await this.getMetadataTags();
+    return splitNames(tags.composer ?? tags.performer);
+  }
+  async setNarrators(narrators) {
+    const tags = await this.getMetadataTags();
+    tags.composer = narrators.join(";");
+    tags.performer = narrators.join(";");
+  }
+  async getCoverArt() {
+    const info = await this.getInfo();
+    return info.attachedPic || null;
+  }
+  async setCoverArt(picture) {
+    const info = await this.getInfo();
+    info.attachedPic = picture;
+  }
+  async getPublisher() {
+    const tags = await this.getMetadataTags();
+    return tags.publisher ?? null;
+  }
+  async setPublisher(publisher) {
+    const tags = await this.getMetadataTags();
+    tags.publisher = publisher;
+  }
+  async getReleaseDate() {
+    const tags = await this.getMetadataTags();
+    return tags.date ? new Date(tags.date) : null;
+  }
+  async setReleaseDate(date) {
+    const tags = await this.getMetadataTags();
+    tags.date = `${date.getDate().toString().padStart(2, "0")}-${date.getMonth().toString().padStart(2, "0")}-${date.getFullYear()}`;
+  }
+  async getDuration() {
+    const info = await this.getInfo();
+    return info.duration;
+  }
+  async getResource() {
+    const duration = await this.getDuration();
+    const title = await this.getTrackTitle() ?? null;
+    const type = (0, import_mime.lookupAudioMime)(this.filename);
+    return {
+      filename: this.filename,
+      title,
+      type,
+      duration,
+      bitrate: null
+    };
+  }
+  async getChapters() {
+    const info = await this.getInfo();
+    return info.chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title ?? null,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const info = await this.getInfo();
+    await (0, import_ffmpeg.writeTrackMetadata)(this.filename, info.tags, info.attachedPic);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/entry.d.cts

@@ -1,19 +1,38 @@
-import { Entry } from '@zip.js/zip.js';
-import { File } from 'node-taglib-sharp';
-import { BaseAudiobookEntry } from './base.cjs';
+import { TrackInfo, AttachedPic } from './ffmpeg.cjs';
+import { AudiobookResource, AudiobookChapter } from './resources.cjs';
 
 interface Uint8ArrayEntry {
     filename: string;
     data: Uint8Array;
 }
-declare class AudiobookEntry extends BaseAudiobookEntry {
-    protected entry: Uint8ArrayEntry | Entry;
+declare class AudiobookEntry {
     filename: string;
-    protected file: File | null;
-    protected readData(): Promise<Uint8Array<ArrayBufferLike>>;
-    getData(): Promise<Uint8Array<ArrayBufferLike>>;
-    createFile(): Promise<File>;
-    constructor(entry: Uint8ArrayEntry | Entry);
+    private info;
+    constructor(filename: string);
+    getInfo(): Promise<TrackInfo>;
+    getMetadataTags(): Promise<TrackInfo["tags"]>;
+    getTitle(): Promise<string | null>;
+    setTitle(title: string): Promise<void>;
+    getTrackTitle(): Promise<string | null>;
+    setTrackTitle(trackTitle: string): Promise<void>;
+    getSubtitle(): Promise<string | null>;
+    setSubtitle(subtitle: string): Promise<void>;
+    getDescription(): Promise<string | null>;
+    setDescription(description: string): Promise<void>;
+    getAuthors(): Promise<string[]>;
+    setAuthors(authors: string[]): Promise<void>;
+    getNarrators(): Promise<string[]>;
+    setNarrators(narrators: string[]): Promise<void>;
+    getCoverArt(): Promise<AttachedPic | null>;
+    setCoverArt(picture: AttachedPic): Promise<void>;
+    getPublisher(): Promise<string | null>;
+    setPublisher(publisher: string): Promise<void>;
+    getReleaseDate(): Promise<Date | null>;
+    setReleaseDate(date: Date): Promise<void>;
+    getDuration(): Promise<number>;
+    getResource(): Promise<AudiobookResource>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    saveAndClose(): Promise<void>;
 }
 
 export { AudiobookEntry, type Uint8ArrayEntry };

package/dist/entry.d.ts

@@ -1,19 +1,38 @@
-import { Entry } from '@zip.js/zip.js';
-import { File } from 'node-taglib-sharp';
-import { BaseAudiobookEntry } from './base.js';
+import { TrackInfo, AttachedPic } from './ffmpeg.js';
+import { AudiobookResource, AudiobookChapter } from './resources.js';
 
 interface Uint8ArrayEntry {
     filename: string;
     data: Uint8Array;
 }
-declare class AudiobookEntry extends BaseAudiobookEntry {
-    protected entry: Uint8ArrayEntry | Entry;
+declare class AudiobookEntry {
     filename: string;
-    protected file: File | null;
-    protected readData(): Promise<Uint8Array<ArrayBufferLike>>;
-    getData(): Promise<Uint8Array<ArrayBufferLike>>;
-    createFile(): Promise<File>;
-    constructor(entry: Uint8ArrayEntry | Entry);
+    private info;
+    constructor(filename: string);
+    getInfo(): Promise<TrackInfo>;
+    getMetadataTags(): Promise<TrackInfo["tags"]>;
+    getTitle(): Promise<string | null>;
+    setTitle(title: string): Promise<void>;
+    getTrackTitle(): Promise<string | null>;
+    setTrackTitle(trackTitle: string): Promise<void>;
+    getSubtitle(): Promise<string | null>;
+    setSubtitle(subtitle: string): Promise<void>;
+    getDescription(): Promise<string | null>;
+    setDescription(description: string): Promise<void>;
+    getAuthors(): Promise<string[]>;
+    setAuthors(authors: string[]): Promise<void>;
+    getNarrators(): Promise<string[]>;
+    setNarrators(narrators: string[]): Promise<void>;
+    getCoverArt(): Promise<AttachedPic | null>;
+    setCoverArt(picture: AttachedPic): Promise<void>;
+    getPublisher(): Promise<string | null>;
+    setPublisher(publisher: string): Promise<void>;
+    getReleaseDate(): Promise<Date | null>;
+    setReleaseDate(date: Date): Promise<void>;
+    getDuration(): Promise<number>;
+    getResource(): Promise<AudiobookResource>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    saveAndClose(): Promise<void>;
 }
 
 export { AudiobookEntry, type Uint8ArrayEntry };

package/dist/entry.js

@@ -1,31 +1,127 @@
-import { Uint8ArrayWriter } from "@zip.js/zip.js";
-import { File } from "node-taglib-sharp";
-import { BaseAudiobookEntry } from "./base.js";
-import { Uint8ArrayFileAbstraction } from "./taglib/Uint8ArrayFileAbstraction.js";
-class AudiobookEntry extends BaseAudiobookEntry {
-  constructor(entry) {
-    super();
-    this.entry = entry;
-    this.filename = entry.filename;
-  }
-  filename;
-  file = null;
-  async readData() {
-    if ("data" in this.entry) {
-      return this.entry.data;
-    }
-    const writer = new Uint8ArrayWriter();
-    return await this.entry.getData(writer);
-  }
-  async getData() {
-    const file = await this.getFile();
-    return file.fileAbstraction.data;
-  }
-  async createFile() {
-    const data = await this.readData();
-    return File.createFromAbstraction(
-      new Uint8ArrayFileAbstraction(this.filename, data)
-    );
+import {
+  getTrackMetadata,
+  writeTrackMetadata
+} from "./ffmpeg.js";
+import { lookupAudioMime } from "./mime.js";
+function splitNames(names) {
+  if (!names) return [];
+  return names.split(/[;,/]/).map((name) => name.trim());
+}
+class AudiobookEntry {
+  constructor(filename) {
+    this.filename = filename;
+  }
+  info = null;
+  async getInfo() {
+    this.info ??= await getTrackMetadata(this.filename);
+    return this.info;
+  }
+  async getMetadataTags() {
+    const info = await this.getInfo();
+    return info.tags;
+  }
+  async getTitle() {
+    const tags = await this.getMetadataTags();
+    return tags.album ?? tags.title ?? null;
+  }
+  async setTitle(title) {
+    const tags = await this.getMetadataTags();
+    tags.album = title;
+  }
+  async getTrackTitle() {
+    const tags = await this.getMetadataTags();
+    return tags.title ?? null;
+  }
+  async setTrackTitle(trackTitle) {
+    const tags = await this.getMetadataTags();
+    tags.title = trackTitle;
+  }
+  async getSubtitle() {
+    const tags = await this.getMetadataTags();
+    return tags.subtitle ?? null;
+  }
+  async setSubtitle(subtitle) {
+    const tags = await this.getMetadataTags();
+    tags.subtitle = subtitle;
+  }
+  async getDescription() {
+    const tags = await this.getMetadataTags();
+    return tags.description ?? tags.comment ?? null;
+  }
+  async setDescription(description) {
+    const tags = await this.getMetadataTags();
+    tags.description = description;
+    tags.comment = description;
+  }
+  async getAuthors() {
+    const tags = await this.getMetadataTags();
+    return splitNames(tags.albumArtist ?? tags.artist);
+  }
+  async setAuthors(authors) {
+    const tags = await this.getMetadataTags();
+    tags.artist = authors.join(";");
+    tags.albumArtist = authors.join(";");
+  }
+  async getNarrators() {
+    const tags = await this.getMetadataTags();
+    return splitNames(tags.composer ?? tags.performer);
+  }
+  async setNarrators(narrators) {
+    const tags = await this.getMetadataTags();
+    tags.composer = narrators.join(";");
+    tags.performer = narrators.join(";");
+  }
+  async getCoverArt() {
+    const info = await this.getInfo();
+    return info.attachedPic || null;
+  }
+  async setCoverArt(picture) {
+    const info = await this.getInfo();
+    info.attachedPic = picture;
+  }
+  async getPublisher() {
+    const tags = await this.getMetadataTags();
+    return tags.publisher ?? null;
+  }
+  async setPublisher(publisher) {
+    const tags = await this.getMetadataTags();
+    tags.publisher = publisher;
+  }
+  async getReleaseDate() {
+    const tags = await this.getMetadataTags();
+    return tags.date ? new Date(tags.date) : null;
+  }
+  async setReleaseDate(date) {
+    const tags = await this.getMetadataTags();
+    tags.date = `${date.getDate().toString().padStart(2, "0")}-${date.getMonth().toString().padStart(2, "0")}-${date.getFullYear()}`;
+  }
+  async getDuration() {
+    const info = await this.getInfo();
+    return info.duration;
+  }
+  async getResource() {
+    const duration = await this.getDuration();
+    const title = await this.getTrackTitle() ?? null;
+    const type = lookupAudioMime(this.filename);
+    return {
+      filename: this.filename,
+      title,
+      type,
+      duration,
+      bitrate: null
+    };
+  }
+  async getChapters() {
+    const info = await this.getInfo();
+    return info.chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title ?? null,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const info = await this.getInfo();
+    await writeTrackMetadata(this.filename, info.tags, info.attachedPic);
   }
 }
 export {

package/dist/ffmpeg.cjs

@@ -0,0 +1,259 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ffmpeg_exports = {};
+__export(ffmpeg_exports, {
+  escapeQuotes: () => escapeQuotes,
+  getTrackMetadata: () => getTrackMetadata,
+  getTrackMetadataFromBuffer: () => getTrackMetadataFromBuffer,
+  quotePath: () => quotePath,
+  writeTrackMetadata: () => writeTrackMetadata
+});
+module.exports = __toCommonJS(ffmpeg_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_node_util = require("node:util");
+var import_path = require("@storyteller-platform/path");
+const execPromise = (0, import_node_util.promisify)(import_node_child_process.exec);
+const execFilePromise = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function execCmd(command) {
+  let stdout = "";
+  let stderr = "";
+  try {
+    ;
+    ({ stdout, stderr } = await execPromise(command));
+    return stdout;
+  } catch (error) {
+    console.error(error);
+    console.warn(stdout);
+    throw new Error(stderr);
+  }
+}
+async function execCmdBuffer(command, args) {
+  var _a, _b;
+  try {
+    const { stdout } = await execFilePromise(command, args, {
+      encoding: "buffer",
+      maxBuffer: 10 * 1024 * 1024,
+      cwd: process.cwd()
+    });
+    return stdout;
+  } catch (error) {
+    console.error(error);
+    if (error && typeof error === "object" && "stdout" in error) {
+      console.warn((_a = error.stdout) == null ? void 0 : _a.toString());
+      throw new Error((_b = error.stdout) == null ? void 0 : _b.toString());
+    }
+    throw error;
+  }
+}
+function escapeQuotes(input) {
+  return input.replaceAll(/"/g, '\\"');
+}
+function quotePath(path) {
+  return `"${escapeQuotes(path)}"`;
+}
+function lookup(codecName) {
+  switch (codecName) {
+    case "mjpeg":
+    case "jpeg": {
+      return "image/jpeg";
+    }
+    case "bmp": {
+      return "image/bmp";
+    }
+    case "png": {
+      return "image/png";
+    }
+    case "gif": {
+      return "image/gif";
+    }
+  }
+}
+async function getTrackMetadata(path) {
+  const stdout = await execCmd(
+    `ffprobe -i ${quotePath(path)} -v quiet -show_format -show_chapters -show_streams -output_format json`
+  );
+  const { chapters, streams, format, duration, bit_rate } = JSON.parse(
+    stdout
+  );
+  const attachedPicStream = streams.find(
+    (stream) => !!stream.disposition.attached_pic
+  );
+  const attachedPic = attachedPicStream && {
+    name: attachedPicStream.tags.title,
+    mimeType: lookup(attachedPicStream.codec_name),
+    kind: attachedPicStream.tags.comment === "Cover (front)" ? "coverFront" : attachedPicStream.tags.comment === "Cover (back)" ? "coverBack" : "unknown",
+    description: attachedPicStream.tags.comment,
+    data: await execCmdBuffer("ffmpeg", [
+      "-nostdin",
+      "-i",
+      path,
+      "-map",
+      "0:v",
+      "-c:v",
+      "copy",
+      "-vframes",
+      "1",
+      "-f",
+      "image2",
+      "-update",
+      "1",
+      "pipe:1"
+    ])
+  };
+  return {
+    duration: parseFloat(duration),
+    bitRate: bit_rate !== void 0 ? parseFloat(bit_rate) : bit_rate,
+    tags: {
+      title: format.tags.title ?? format.tags.Title,
+      subtitle: format.tags.subtitle ?? format.tags.Subtitle,
+      date: format.tags.date ?? format.tags.Date,
+      album: format.tags.album ?? format.tags.Album,
+      albumArtist: format.tags.album_artist ?? format.tags.Album_Artist,
+      artist: format.tags.artist ?? format.tags.Artist,
+      performer: format.tags.performer ?? format.tags.Performer,
+      composer: format.tags.composer ?? format.tags.Composer,
+      comment: format.tags.comment ?? format.tags.Comment,
+      description: format.tags.description ?? format.tags.Description,
+      publisher: format.tags.publisher ?? format.tags.Publisher
+    },
+    chapters: chapters.map(
+      (chapter) => ({
+        id: chapter.id,
+        startTime: parseFloat(chapter.start_time),
+        endTime: parseFloat(chapter.end_time),
+        title: chapter.tags.title
+      })
+    ),
+    attachedPic
+  };
+}
+async function writeTrackMetadata(path, metadata, attachedPic) {
+  const metadataArgs = [];
+  if (metadata.title) {
+    metadataArgs.push(`-metadata title="${escapeQuotes(metadata.title)}"`);
+  }
+  if (metadata.subtitle) {
+    metadataArgs.push(`-metadata subtitle="${escapeQuotes(metadata.subtitle)}"`);
+  }
+  if (metadata.date) {
+    metadataArgs.push(`-metadata date="${escapeQuotes(metadata.date)}"`);
+  }
+  if (metadata.album) {
+    metadataArgs.push(`-metadata album="${escapeQuotes(metadata.album)}"`);
+  }
+  if (metadata.albumArtist) {
+    metadataArgs.push(
+      `-metadata album_artist="${escapeQuotes(metadata.albumArtist)}"`
+    );
+  }
+  if (metadata.artist) {
+    metadataArgs.push(`-metadata artist="${escapeQuotes(metadata.artist)}"`);
+  }
+  if (metadata.performer) {
+    metadataArgs.push(
+      `-metadata performer="${escapeQuotes(metadata.performer)}"`
+    );
+  }
+  if (metadata.composer) {
+    metadataArgs.push(`-metadata composer="${escapeQuotes(metadata.composer)}"`);
+  }
+  if (metadata.comment) {
+    metadataArgs.push(`-metadata comment="${escapeQuotes(metadata.comment)}"`);
+  }
+  if (metadata.description) {
+    metadataArgs.push(
+      `-metadata description="${escapeQuotes(metadata.description)}"`
+    );
+  }
+  if (metadata.publisher) {
+    metadataArgs.push(
+      `-metadata publisher="${escapeQuotes(metadata.publisher)}"`
+    );
+  }
+  const ext = (0, import_path.extname)(path);
+  const tmpPath = (0, import_node_path.join)(
+    (0, import_node_os.tmpdir)(),
+    `storyteller-platform-audiobook-${(0, import_node_crypto.randomUUID)()}${ext}`
+  );
+  let picPath = null;
+  try {
+    if (attachedPic) {
+      const imageExt = attachedPic.mimeType.split("/")[1];
+      picPath = (0, import_node_path.join)(
+        (0, import_node_os.tmpdir)(),
+        `storyteller-platform-audiobook-${(0, import_node_crypto.randomUUID)()}.${imageExt}`
+      );
+      await (0, import_promises.writeFile)(picPath, attachedPic.data);
+      metadataArgs.push(`-disposition:v:0 attached_pic`);
+      if (attachedPic.name) {
+        metadataArgs.push(
+          `-metadata:s:v title="${escapeQuotes(attachedPic.name)}"`
+        );
+      }
+      if (attachedPic.kind !== "unknown") {
+        metadataArgs.push(
+          `-metadata:s:v comment="${attachedPic.kind === "coverFront" ? "Cover (front)" : "Cover (back)"}"`
+        );
+      }
+    }
+    const cmd = `ffmpeg -i "${path}" ${metadataArgs.join(" ")} -codec copy "${tmpPath}"`;
+    await execCmd(cmd);
+    await (0, import_promises.cp)(tmpPath, path, { force: true });
+  } finally {
+    try {
+      await (0, import_promises.rm)(tmpPath);
+    } catch (error) {
+      console.warn(`Failed to clean up temporary file ${tmpPath}:`, error);
+    }
+    if (picPath) {
+      try {
+        await (0, import_promises.rm)(picPath);
+      } catch (error) {
+        console.warn(`Failed to clean up temporary file ${picPath}:`, error);
+      }
+    }
+  }
+}
+async function getTrackMetadataFromBuffer(buffer) {
+  const tempFile = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `ffprobe-${(0, import_node_crypto.randomUUID)()}`);
+  try {
+    (0, import_node_fs.writeFileSync)(tempFile, buffer);
+    const result = await getTrackMetadata(tempFile);
+    return result;
+  } finally {
+    try {
+      await (0, import_promises.rm)(tempFile);
+    } catch (error) {
+      console.warn(`Failed to clean up temporary file ${tempFile}:`, error);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeQuotes,
+  getTrackMetadata,
+  getTrackMetadataFromBuffer,
+  quotePath,
+  writeTrackMetadata
+});