@storyteller-platform/audiobook 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,45 +1,279 @@
-import { Uint8ArrayReader, ZipReader } from "@zip.js/zip.js";
-import { extname } from "@storyteller-platform/path";
-import { BaseAudiobook } from "./base.js";
-import { AudiobookEntry } from "./entry.js";
-class Audiobook extends BaseAudiobook {
-  constructor(entries) {
-    super();
-    this.entries = entries;
-  }
-  static async from(pathOrPathsOrData) {
-    if (!Array.isArray(pathOrPathsOrData)) {
-      const ext = extname(pathOrPathsOrData.filename);
-      if (ext === ".zip") {
-        const dataReader = new Uint8ArrayReader(pathOrPathsOrData.data);
-        const zipReader = new ZipReader(dataReader);
-        const zipEntries = await zipReader.getEntries();
-        const entries = zipEntries.map((entry) => new AudiobookEntry(entry));
-        return new Audiobook(entries);
-      }
-      return new Audiobook([new AudiobookEntry(pathOrPathsOrData)]);
+import { readFile } from "node:fs/promises";
+import { ZipFS } from "@yarnpkg/libzip";
+import { lookup } from "mime-types";
+import { basename, extname } from "@storyteller-platform/path";
+import { BufferEntry } from "./bufferEntry.js";
+import { FileEntry } from "./fileEntry.js";
+import { ZipFSEntry } from "./zipFsEntry.js";
+const COVER_IMAGE_FILE_EXTENSIONS = [
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".svg"
+];
+const MP3_FILE_EXTENSIONS = [".mp3"];
+const MPEG4_FILE_EXTENSIONS = [".mp4", ".m4a", ".m4b"];
+const AAC_FILE_EXTENSIONS = [".aac"];
+const OGG_FILE_EXTENSIONS = [".ogg", ".oga", ".mogg"];
+const OPUS_FILE_EXTENSIONS = [".opus"];
+const WAVE_FILE_EXTENSIONS = [".wav"];
+const AIFF_FILE_EXTENSIONS = [".aiff"];
+const FLAC_FILE_EXTENSIONS = [".flac"];
+const ALAC_FILE_EXTENSIONS = [".alac"];
+const WEBM_FILE_EXTENSIONS = [".weba"];
+const AUDIO_FILE_EXTENSIONS = [
+  ...MP3_FILE_EXTENSIONS,
+  ...AAC_FILE_EXTENSIONS,
+  ...MPEG4_FILE_EXTENSIONS,
+  ...OPUS_FILE_EXTENSIONS,
+  ...OGG_FILE_EXTENSIONS,
+  ...WAVE_FILE_EXTENSIONS,
+  ...AIFF_FILE_EXTENSIONS,
+  ...FLAC_FILE_EXTENSIONS,
+  ...ALAC_FILE_EXTENSIONS,
+  ...WEBM_FILE_EXTENSIONS
+];
+class Audiobook {
+  metadata = {};
+  inputs;
+  entries;
+  constructor(...inputs) {
+    this.inputs = inputs;
+    this.entries = this.getEntries();
+  }
+  isZip() {
+    const [first] = this.inputs;
+    return typeof first === "string" && (extname(first) === ".zip" || extname(first) === ".audiobook");
+  }
+  isFiles() {
+    const [first] = this.inputs;
+    return typeof first === "string" && !this.isZip();
+  }
+  isInMemory() {
+    const [first] = this.inputs;
+    return typeof first !== "string";
+  }
+  getEntries() {
+    if (this.isZip()) {
+      const [first] = this.inputs;
+      const zipFs = new ZipFS(first);
+      const entries = zipFs.getAllFiles();
+      return entries.filter(
+        (entry) => AUDIO_FILE_EXTENSIONS.includes(
+          extname(entry)
+        )
+      ).map((entry) => new ZipFSEntry(zipFs, entry));
     }
-    return new Audiobook(
-      pathOrPathsOrData.map((path) => new AudiobookEntry(path))
-    );
+    if (this.isFiles()) {
+      return this.inputs.map((input) => new FileEntry(input));
+    }
+    if (this.isInMemory()) {
+      return this.inputs.map(
+        (input) => new BufferEntry(input)
+      );
+    }
+    return [];
   }
-  static create(metadata) {
-    const audiobook = new Audiobook([]);
-    audiobook.metadata = metadata;
-    return audiobook;
+  async getFirstValue(getter) {
+    for (const entry of this.entries) {
+      const value = await getter(entry);
+      if (value) return value;
+    }
+    return null;
   }
-  async save() {
+  async setValue(setter) {
     for (const entry of this.entries) {
-      entry.save();
+      await setter(entry);
     }
-    return await Promise.all(
-      this.entries.map(async (entry) => ({
-        filename: entry.filename,
-        data: await entry.getData()
-      }))
+  }
+  async getTitle() {
+    this.metadata.title ??= await this.getFirstValue(
+      (entry) => entry.getTitle()
+    );
+    return this.metadata.title;
+  }
+  async setTitle(title) {
+    this.metadata.title = title;
+    await this.setValue((entry) => entry.setTitle(title));
+  }
+  async getSubtitle() {
+    this.metadata.subtitle ??= await this.getFirstValue(
+      (entry) => entry.getSubtitle()
+    );
+    return this.metadata.subtitle;
+  }
+  async setSubtitle(subtitle) {
+    this.metadata.subtitle = subtitle;
+    await this.setValue((entry) => entry.setSubtitle(subtitle));
+  }
+  async getDescription() {
+    this.metadata.description ??= await this.getFirstValue(
+      (entry) => entry.getDescription()
+    );
+    return this.metadata.description;
+  }
+  async setDescription(description) {
+    this.metadata.description = description;
+    await this.setValue((entry) => entry.setDescription(description));
+  }
+  async getAuthors() {
+    this.metadata.authors ??= await this.getFirstValue(
+      (entry) => entry.getAuthors()
+    );
+    return this.metadata.authors ?? [];
+  }
+  async setAuthors(authors) {
+    this.metadata.authors = authors;
+    await this.setValue((entry) => entry.setAuthors(authors));
+  }
+  async getNarrators() {
+    this.metadata.narrators ??= await this.getFirstValue(
+      (entry) => entry.getNarrators()
+    );
+    return this.metadata.narrators ?? [];
+  }
+  async setNarrators(narrators) {
+    this.metadata.narrators = narrators;
+    await this.setValue((entry) => entry.setNarrators(narrators));
+  }
+  async getCoverArt() {
+    this.metadata.coverArt ??= await this.getFirstValue(
+      (entry) => entry.getCoverArt()
+    );
+    return this.metadata.coverArt;
+  }
+  async setCoverArt(picture) {
+    this.metadata.coverArt = picture;
+    await this.setValue((entry) => entry.setCoverArt(picture));
+  }
+  async getPublisher() {
+    this.metadata.publisher ??= await this.getFirstValue(
+      (entry) => entry.getPublisher()
     );
+    return this.metadata.publisher;
   }
+  async setPublisher(publisher) {
+    this.metadata.publisher = publisher;
+    await this.setValue((entry) => entry.setPublisher(publisher));
+  }
+  async getReleaseDate() {
+    this.metadata.releaseDate ??= await this.getFirstValue(
+      (entry) => entry.getReleaseDate()
+    );
+    return this.metadata.releaseDate;
+  }
+  async setReleaseDate(date) {
+    this.metadata.releaseDate = date;
+    await this.setValue((entry) => entry.setReleaseDate(date));
+  }
+  async getDuration() {
+    let duration = 0;
+    for (const entry of this.entries) {
+      duration += await entry.getDuration();
+    }
+    return duration;
+  }
+  async getChapters() {
+    if (this.metadata.chapters) return this.metadata.chapters;
+    const chapters = [];
+    for (const entry of this.entries) {
+      const entryChapters = await entry.getChapters();
+      if (entryChapters.length) {
+        chapters.push(...entryChapters);
+      } else {
+        chapters.push({
+          filename: entry.filename,
+          start: 0,
+          title: await entry.getTrackTitle() ?? basename(entry.filename, extname(entry.filename))
+        });
+      }
+    }
+    this.metadata.chapters = chapters;
+    return chapters;
+  }
+  async getResources() {
+    if (this.metadata.resources) return this.metadata.resources;
+    const resources = [];
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      const resource = await entry.getResource();
+      if (!resource.title) {
+        resource.title = `Track ${i + 1}`;
+      }
+      resources.push(resource);
+    }
+    this.metadata.resources = resources;
+    return resources;
+  }
+  async getArraysAndClose() {
+    const output = [];
+    for (const entry of this.entries) {
+      output.push(await entry.getArrayAndClose());
+    }
+    if (this.isZip()) {
+      const zipFs = this.entries[0].zipFs;
+      zipFs.discardAndClose();
+    }
+    return output;
+  }
+  async saveAndClose() {
+    if (this.isZip()) {
+      for (const entry of this.entries) {
+        await entry.saveAndClose();
+      }
+      const zipFs = this.entries[0].zipFs;
+      zipFs.saveAndClose();
+      return;
+    }
+    if (this.isFiles()) {
+      for (const entry of this.entries) {
+        await entry.saveAndClose();
+      }
+    }
+    if (this.isInMemory()) {
+      throw new Error(
+        `Cannot save in-memory Audiobooks. Use audiobook.getArraysAndClose() to access the updated array.`
+      );
+    }
+  }
+  discardAndClose() {
+    if (this.isZip()) {
+      const zipFs = this.entries[0].zipFs;
+      if (zipFs.ready) {
+        zipFs.discardAndClose();
+      }
+    }
+    this.inputs = [".mp3"];
+    this.entries = [];
+  }
+  [Symbol.dispose]() {
+    this.discardAndClose();
+  }
+}
+async function getAttachedImageFromPath(path, kind = "coverFront", description) {
+  const data = await readFile(path);
+  const name = basename(path);
+  const mimeType = lookup(path) || "";
+  return {
+    data: new Uint8Array(data),
+    name,
+    kind,
+    ...description && { description },
+    mimeType
+  };
 }
 export {
-  Audiobook
+  AAC_FILE_EXTENSIONS,
+  AIFF_FILE_EXTENSIONS,
+  ALAC_FILE_EXTENSIONS,
+  Audiobook,
+  COVER_IMAGE_FILE_EXTENSIONS,
+  FLAC_FILE_EXTENSIONS,
+  MP3_FILE_EXTENSIONS,
+  MPEG4_FILE_EXTENSIONS,
+  OGG_FILE_EXTENSIONS,
+  OPUS_FILE_EXTENSIONS,
+  WAVE_FILE_EXTENSIONS,
+  WEBM_FILE_EXTENSIONS,
+  getAttachedImageFromPath
 };

package/dist/resources.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 resources_exports = {};
+module.exports = __toCommonJS(resources_exports);

package/dist/resources.d.cts

@@ -0,0 +1,14 @@
+interface AudiobookChapter {
+    filename: string;
+    start: number | null;
+    title: string;
+}
+interface AudiobookResource {
+    filename: string;
+    type: string;
+    bitrate: number | null;
+    duration: number;
+    title: string | null;
+}
+
+export type { AudiobookChapter, AudiobookResource };

package/dist/resources.d.ts

@@ -0,0 +1,14 @@
+interface AudiobookChapter {
+    filename: string;
+    start: number | null;
+    title: string;
+}
+interface AudiobookResource {
+    filename: string;
+    type: string;
+    bitrate: number | null;
+    duration: number;
+    title: string | null;
+}
+
+export type { AudiobookChapter, AudiobookResource };

package/dist/tagMaps.cjs

@@ -0,0 +1,120 @@
+"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 tagMaps_exports = {};
+__export(tagMaps_exports, {
+  getWriteTags: () => getWriteTags,
+  readTagMap: () => readTagMap
+});
+module.exports = __toCommonJS(tagMaps_exports);
+var import_mediabunny = require("mediabunny");
+const readTagMap = {
+  trackTitle: ["TT2", "TIT2", "\xA9nam"],
+  title: ["TAL", "TALB", "TT2", "TIT2", "\xA9alb", "\xA9nam"],
+  subtitle: ["TT3", "TIT3", "Subt", "----:com.apple.iTunes:SUBTITLE", "\xA9gen"],
+  description: [
+    "COM",
+    "TDES",
+    "COMM",
+    "\xA9des",
+    "ldes",
+    "desc",
+    "\xA9cmt",
+    "\xA9com",
+    "----:com.apple.iTunes:NOTES"
+  ],
+  authors: [
+    // albumArtists
+    "TP2",
+    "TPE2",
+    "aART",
+    "----:com.apple.iTunes:Band",
+    // artists
+    "TP1",
+    "TPE1",
+    "TXXX:Artists",
+    "\xA9ART",
+    "----:com.apple.iTunes:ARTISTS"
+  ],
+  narrators: [
+    // Narrator tag, almost never used
+    "\xA9nrt",
+    // composers
+    "TCM",
+    "TCOM",
+    "\xA9wrt",
+    // conductors
+    "TP3",
+    "TPE3",
+    "----:com.apple.iTunes:CONDUCTOR",
+    "\xA9con",
+    "cond"
+  ],
+  publisher: ["\xA9pub"],
+  releaseDate: ["TDR", "TDRL", "rldt"]
+};
+const writeIdv3TagMap = {
+  title: ["TALB"],
+  subtitle: ["TIT3"],
+  description: ["TDES", "COMM"],
+  authors: ["TPE2", "TPE1", "TXXX:Artists"],
+  narrators: ["TCOM", "TPE3"],
+  publisher: [],
+  releaseDate: ["TDRL"]
+};
+const writeMp4TagMap = {
+  title: ["\xA9alb"],
+  subtitle: ["Subt", "----:com.apple.iTunes:SUBTITLE"],
+  description: [
+    "\xA9des",
+    "ldes",
+    "desc",
+    "\xA9cmt",
+    "\xA9com",
+    "----:com.apple.iTunes:NOTES"
+  ],
+  authors: [
+    "aART",
+    "----:com.apple.iTunes:Band",
+    "\xA9ART",
+    "----:com.apple.iTunes:ARTISTS"
+  ],
+  narrators: [
+    "\xA9nrt",
+    "\xA9wrt",
+    "----:com.apple.iTunes:CONDUCTOR",
+    "\xA9con",
+    "cond"
+  ],
+  publisher: ["\xA9pub"],
+  releaseDate: ["rldt"]
+};
+function getWriteTags(format, tag) {
+  if (format === import_mediabunny.MP3) {
+    return writeIdv3TagMap[tag];
+  }
+  if (format === import_mediabunny.MP4) {
+    return writeMp4TagMap[tag];
+  }
+  return [];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWriteTags,
+  readTagMap
+});

package/dist/tagMaps.d.cts

@@ -0,0 +1,24 @@
+import { InputFormat } from 'mediabunny';
+
+declare const readTagMap: {
+    trackTitle: string[];
+    title: string[];
+    subtitle: string[];
+    description: string[];
+    authors: string[];
+    narrators: string[];
+    publisher: string[];
+    releaseDate: string[];
+};
+declare const writeIdv3TagMap: {
+    title: string[];
+    subtitle: string[];
+    description: string[];
+    authors: string[];
+    narrators: string[];
+    publisher: never[];
+    releaseDate: string[];
+};
+declare function getWriteTags(format: InputFormat, tag: keyof typeof writeIdv3TagMap): string[];
+
+export { getWriteTags, readTagMap };

package/dist/tagMaps.d.ts

@@ -0,0 +1,24 @@
+import { InputFormat } from 'mediabunny';
+
+declare const readTagMap: {
+    trackTitle: string[];
+    title: string[];
+    subtitle: string[];
+    description: string[];
+    authors: string[];
+    narrators: string[];
+    publisher: string[];
+    releaseDate: string[];
+};
+declare const writeIdv3TagMap: {
+    title: string[];
+    subtitle: string[];
+    description: string[];
+    authors: string[];
+    narrators: string[];
+    publisher: never[];
+    releaseDate: string[];
+};
+declare function getWriteTags(format: InputFormat, tag: keyof typeof writeIdv3TagMap): string[];
+
+export { getWriteTags, readTagMap };

package/dist/tagMaps.js

@@ -0,0 +1,95 @@
+import { MP3, MP4 } from "mediabunny";
+const readTagMap = {
+  trackTitle: ["TT2", "TIT2", "\xA9nam"],
+  title: ["TAL", "TALB", "TT2", "TIT2", "\xA9alb", "\xA9nam"],
+  subtitle: ["TT3", "TIT3", "Subt", "----:com.apple.iTunes:SUBTITLE", "\xA9gen"],
+  description: [
+    "COM",
+    "TDES",
+    "COMM",
+    "\xA9des",
+    "ldes",
+    "desc",
+    "\xA9cmt",
+    "\xA9com",
+    "----:com.apple.iTunes:NOTES"
+  ],
+  authors: [
+    // albumArtists
+    "TP2",
+    "TPE2",
+    "aART",
+    "----:com.apple.iTunes:Band",
+    // artists
+    "TP1",
+    "TPE1",
+    "TXXX:Artists",
+    "\xA9ART",
+    "----:com.apple.iTunes:ARTISTS"
+  ],
+  narrators: [
+    // Narrator tag, almost never used
+    "\xA9nrt",
+    // composers
+    "TCM",
+    "TCOM",
+    "\xA9wrt",
+    // conductors
+    "TP3",
+    "TPE3",
+    "----:com.apple.iTunes:CONDUCTOR",
+    "\xA9con",
+    "cond"
+  ],
+  publisher: ["\xA9pub"],
+  releaseDate: ["TDR", "TDRL", "rldt"]
+};
+const writeIdv3TagMap = {
+  title: ["TALB"],
+  subtitle: ["TIT3"],
+  description: ["TDES", "COMM"],
+  authors: ["TPE2", "TPE1", "TXXX:Artists"],
+  narrators: ["TCOM", "TPE3"],
+  publisher: [],
+  releaseDate: ["TDRL"]
+};
+const writeMp4TagMap = {
+  title: ["\xA9alb"],
+  subtitle: ["Subt", "----:com.apple.iTunes:SUBTITLE"],
+  description: [
+    "\xA9des",
+    "ldes",
+    "desc",
+    "\xA9cmt",
+    "\xA9com",
+    "----:com.apple.iTunes:NOTES"
+  ],
+  authors: [
+    "aART",
+    "----:com.apple.iTunes:Band",
+    "\xA9ART",
+    "----:com.apple.iTunes:ARTISTS"
+  ],
+  narrators: [
+    "\xA9nrt",
+    "\xA9wrt",
+    "----:com.apple.iTunes:CONDUCTOR",
+    "\xA9con",
+    "cond"
+  ],
+  publisher: ["\xA9pub"],
+  releaseDate: ["rldt"]
+};
+function getWriteTags(format, tag) {
+  if (format === MP3) {
+    return writeIdv3TagMap[tag];
+  }
+  if (format === MP4) {
+    return writeMp4TagMap[tag];
+  }
+  return [];
+}
+export {
+  getWriteTags,
+  readTagMap
+};

package/dist/zipFsEntry.cjs

@@ -0,0 +1,65 @@
+"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 zipFsEntry_exports = {};
+__export(zipFsEntry_exports, {
+  ZipFSEntry: () => ZipFSEntry
+});
+module.exports = __toCommonJS(zipFsEntry_exports);
+var import_mediabunny = require("mediabunny");
+var import_entry = require("./entry.cjs");
+var import_ffmpeg = require("./ffmpeg.cjs");
+class ZipFSEntry extends import_entry.AudiobookEntry {
+  constructor(zipFs, filename) {
+    super();
+    this.zipFs = zipFs;
+    this.filename = filename;
+  }
+  input = null;
+  data = null;
+  async getInput() {
+    if (this.input) return this.input;
+    this.data ??= await this.zipFs.readFilePromise(this.filename);
+    this.input = new import_mediabunny.Input({
+      formats: import_mediabunny.ALL_FORMATS,
+      source: new import_mediabunny.BufferSource(this.data)
+    });
+    return this.input;
+  }
+  async getChapters() {
+    this.data ??= await this.zipFs.readFilePromise(this.filename);
+    const chapters = await (0, import_ffmpeg.getTrackChaptersFromBuffer)(this.data);
+    return chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const { data } = await this.getArrayAndClose();
+    await this.zipFs.writeFilePromise(
+      this.filename,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      new Uint8Array(data)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZipFSEntry
+});