@storyteller-platform/audiobook 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -18,52 +18,298 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
-  Audiobook: () => Audiobook
+  AAC_FILE_EXTENSIONS: () => AAC_FILE_EXTENSIONS,
+  AIFF_FILE_EXTENSIONS: () => AIFF_FILE_EXTENSIONS,
+  ALAC_FILE_EXTENSIONS: () => ALAC_FILE_EXTENSIONS,
+  Audiobook: () => Audiobook,
+  COVER_IMAGE_FILE_EXTENSIONS: () => COVER_IMAGE_FILE_EXTENSIONS,
+  FLAC_FILE_EXTENSIONS: () => FLAC_FILE_EXTENSIONS,
+  MP3_FILE_EXTENSIONS: () => MP3_FILE_EXTENSIONS,
+  MPEG4_FILE_EXTENSIONS: () => MPEG4_FILE_EXTENSIONS,
+  OGG_FILE_EXTENSIONS: () => OGG_FILE_EXTENSIONS,
+  OPUS_FILE_EXTENSIONS: () => OPUS_FILE_EXTENSIONS,
+  WAVE_FILE_EXTENSIONS: () => WAVE_FILE_EXTENSIONS,
+  WEBM_FILE_EXTENSIONS: () => WEBM_FILE_EXTENSIONS,
+  getAttachedImageFromPath: () => getAttachedImageFromPath
 });
 module.exports = __toCommonJS(index_exports);
-var import_zip = require("@zip.js/zip.js");
+var import_promises = require("node:fs/promises");
+var import_libzip = require("@yarnpkg/libzip");
+var import_mime_types = require("mime-types");
 var import_path = require("@storyteller-platform/path");
-var import_base = require("./base.cjs");
-var import_entry = require("./entry.cjs");
-class Audiobook extends import_base.BaseAudiobook {
-  constructor(entries) {
-    super();
-    this.entries = entries;
-  }
-  static async from(pathOrPathsOrData) {
-    if (!Array.isArray(pathOrPathsOrData)) {
-      const ext = (0, import_path.extname)(pathOrPathsOrData.filename);
-      if (ext === ".zip") {
-        const dataReader = new import_zip.Uint8ArrayReader(pathOrPathsOrData.data);
-        const zipReader = new import_zip.ZipReader(dataReader);
-        const zipEntries = await zipReader.getEntries();
-        const entries = zipEntries.map((entry) => new import_entry.AudiobookEntry(entry));
-        return new Audiobook(entries);
-      }
-      return new Audiobook([new import_entry.AudiobookEntry(pathOrPathsOrData)]);
+var import_bufferEntry = require("./bufferEntry.cjs");
+var import_fileEntry = require("./fileEntry.cjs");
+var import_zipFsEntry = require("./zipFsEntry.cjs");
+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" && ((0, import_path.extname)(first) === ".zip" || (0, import_path.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 import_libzip.ZipFS(first);
+      const entries = zipFs.getAllFiles();
+      return entries.filter(
+        (entry) => AUDIO_FILE_EXTENSIONS.includes(
+          (0, import_path.extname)(entry)
+        )
+      ).map((entry) => new import_zipFsEntry.ZipFSEntry(zipFs, entry));
     }
-    return new Audiobook(
-      pathOrPathsOrData.map((path) => new import_entry.AudiobookEntry(path))
-    );
+    if (this.isFiles()) {
+      return this.inputs.map((input) => new import_fileEntry.FileEntry(input));
+    }
+    if (this.isInMemory()) {
+      return this.inputs.map(
+        (input) => new import_bufferEntry.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() ?? (0, import_path.basename)(entry.filename, (0, import_path.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 (0, import_promises.readFile)(path);
+  const name = (0, import_path.basename)(path);
+  const mimeType = (0, import_mime_types.lookup)(path) || "";
+  return {
+    data: new Uint8Array(data),
+    name,
+    kind,
+    ...description && { description },
+    mimeType
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  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/index.d.cts

@@ -1,14 +1,70 @@
-import { BaseAudiobook, AudiobookMetadata } from './base.cjs';
-import { AudiobookEntry, Uint8ArrayEntry } from './entry.cjs';
-import 'node-taglib-sharp';
-import '@zip.js/zip.js';
+import { AttachedImage } from 'mediabunny';
+import { Uint8ArrayEntry, AudiobookEntry } from './entry.cjs';
+import { AudiobookChapter, AudiobookResource } from './resources.cjs';
 
-declare class Audiobook extends BaseAudiobook {
-    protected entries: AudiobookEntry[];
-    protected constructor(entries: AudiobookEntry[]);
-    static from(pathOrPathsOrData: Uint8ArrayEntry | Uint8ArrayEntry[]): Promise<Audiobook>;
-    static create(metadata: AudiobookMetadata): Audiobook;
-    save(): Promise<Uint8ArrayEntry[]>;
+interface AudiobookMetadata {
+    title?: string | null;
+    subtitle?: string | null;
+    description?: string | null;
+    coverArt?: AttachedImage | null;
+    chapters?: AudiobookChapter[] | null;
+    resources?: AudiobookResource[] | null;
+    authors?: string[] | null;
+    narrators?: string[] | null;
+    publisher?: string | null;
+    releaseDate?: Date | null;
 }
+declare const COVER_IMAGE_FILE_EXTENSIONS: readonly [".jpeg", ".jpg", ".png", ".svg"];
+declare const MP3_FILE_EXTENSIONS: readonly [".mp3"];
+declare const MPEG4_FILE_EXTENSIONS: readonly [".mp4", ".m4a", ".m4b"];
+declare const AAC_FILE_EXTENSIONS: readonly [".aac"];
+declare const OGG_FILE_EXTENSIONS: readonly [".ogg", ".oga", ".mogg"];
+declare const OPUS_FILE_EXTENSIONS: readonly [".opus"];
+declare const WAVE_FILE_EXTENSIONS: readonly [".wav"];
+declare const AIFF_FILE_EXTENSIONS: readonly [".aiff"];
+declare const FLAC_FILE_EXTENSIONS: readonly [".flac"];
+declare const ALAC_FILE_EXTENSIONS: readonly [".alac"];
+declare const WEBM_FILE_EXTENSIONS: readonly [".weba"];
+declare const AUDIO_FILE_EXTENSIONS: readonly [".mp3", ".aac", ".mp4", ".m4a", ".m4b", ".opus", ".ogg", ".oga", ".mogg", ".wav", ".aiff", ".flac", ".alac", ".weba"];
+type AudiobookInputs = [`${string}.zip`] | [`${string}.audiobook`] | [
+    `${string}${(typeof AUDIO_FILE_EXTENSIONS)[number]}`,
+    ...`${string}${(typeof AUDIO_FILE_EXTENSIONS)[number]}`[]
+] | [Uint8ArrayEntry, ...Uint8ArrayEntry[]];
+declare class Audiobook {
+    protected metadata: AudiobookMetadata;
+    private inputs;
+    private entries;
+    constructor(...inputs: AudiobookInputs);
+    private isZip;
+    private isFiles;
+    private isInMemory;
+    private getEntries;
+    protected getFirstValue<T>(getter: (entry: AudiobookEntry) => Promise<T>): Promise<T | null>;
+    protected setValue(setter: (entry: AudiobookEntry) => Promise<void>): Promise<void>;
+    getTitle(): Promise<string | null>;
+    setTitle(title: 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<AttachedImage | null>;
+    setCoverArt(picture: AttachedImage): Promise<void>;
+    getPublisher(): Promise<string | null>;
+    setPublisher(publisher: string): Promise<void>;
+    getReleaseDate(): Promise<Date | null>;
+    setReleaseDate(date: Date): Promise<void>;
+    getDuration(): Promise<number>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    getResources(): Promise<AudiobookResource[]>;
+    getArraysAndClose(): Promise<Uint8ArrayEntry[]>;
+    saveAndClose(): Promise<void>;
+    discardAndClose(): void;
+    [Symbol.dispose](): void;
+}
+declare function getAttachedImageFromPath(path: string, kind?: AttachedImage["kind"], description?: string): Promise<AttachedImage>;
 
-export { Audiobook };
+export { AAC_FILE_EXTENSIONS, AIFF_FILE_EXTENSIONS, ALAC_FILE_EXTENSIONS, Audiobook, type AudiobookInputs, type AudiobookMetadata, 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/index.d.ts

@@ -1,14 +1,70 @@
-import { BaseAudiobook, AudiobookMetadata } from './base.js';
-import { AudiobookEntry, Uint8ArrayEntry } from './entry.js';
-import 'node-taglib-sharp';
-import '@zip.js/zip.js';
+import { AttachedImage } from 'mediabunny';
+import { Uint8ArrayEntry, AudiobookEntry } from './entry.js';
+import { AudiobookChapter, AudiobookResource } from './resources.js';
 
-declare class Audiobook extends BaseAudiobook {
-    protected entries: AudiobookEntry[];
-    protected constructor(entries: AudiobookEntry[]);
-    static from(pathOrPathsOrData: Uint8ArrayEntry | Uint8ArrayEntry[]): Promise<Audiobook>;
-    static create(metadata: AudiobookMetadata): Audiobook;
-    save(): Promise<Uint8ArrayEntry[]>;
+interface AudiobookMetadata {
+    title?: string | null;
+    subtitle?: string | null;
+    description?: string | null;
+    coverArt?: AttachedImage | null;
+    chapters?: AudiobookChapter[] | null;
+    resources?: AudiobookResource[] | null;
+    authors?: string[] | null;
+    narrators?: string[] | null;
+    publisher?: string | null;
+    releaseDate?: Date | null;
 }
+declare const COVER_IMAGE_FILE_EXTENSIONS: readonly [".jpeg", ".jpg", ".png", ".svg"];
+declare const MP3_FILE_EXTENSIONS: readonly [".mp3"];
+declare const MPEG4_FILE_EXTENSIONS: readonly [".mp4", ".m4a", ".m4b"];
+declare const AAC_FILE_EXTENSIONS: readonly [".aac"];
+declare const OGG_FILE_EXTENSIONS: readonly [".ogg", ".oga", ".mogg"];
+declare const OPUS_FILE_EXTENSIONS: readonly [".opus"];
+declare const WAVE_FILE_EXTENSIONS: readonly [".wav"];
+declare const AIFF_FILE_EXTENSIONS: readonly [".aiff"];
+declare const FLAC_FILE_EXTENSIONS: readonly [".flac"];
+declare const ALAC_FILE_EXTENSIONS: readonly [".alac"];
+declare const WEBM_FILE_EXTENSIONS: readonly [".weba"];
+declare const AUDIO_FILE_EXTENSIONS: readonly [".mp3", ".aac", ".mp4", ".m4a", ".m4b", ".opus", ".ogg", ".oga", ".mogg", ".wav", ".aiff", ".flac", ".alac", ".weba"];
+type AudiobookInputs = [`${string}.zip`] | [`${string}.audiobook`] | [
+    `${string}${(typeof AUDIO_FILE_EXTENSIONS)[number]}`,
+    ...`${string}${(typeof AUDIO_FILE_EXTENSIONS)[number]}`[]
+] | [Uint8ArrayEntry, ...Uint8ArrayEntry[]];
+declare class Audiobook {
+    protected metadata: AudiobookMetadata;
+    private inputs;
+    private entries;
+    constructor(...inputs: AudiobookInputs);
+    private isZip;
+    private isFiles;
+    private isInMemory;
+    private getEntries;
+    protected getFirstValue<T>(getter: (entry: AudiobookEntry) => Promise<T>): Promise<T | null>;
+    protected setValue(setter: (entry: AudiobookEntry) => Promise<void>): Promise<void>;
+    getTitle(): Promise<string | null>;
+    setTitle(title: 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<AttachedImage | null>;
+    setCoverArt(picture: AttachedImage): Promise<void>;
+    getPublisher(): Promise<string | null>;
+    setPublisher(publisher: string): Promise<void>;
+    getReleaseDate(): Promise<Date | null>;
+    setReleaseDate(date: Date): Promise<void>;
+    getDuration(): Promise<number>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    getResources(): Promise<AudiobookResource[]>;
+    getArraysAndClose(): Promise<Uint8ArrayEntry[]>;
+    saveAndClose(): Promise<void>;
+    discardAndClose(): void;
+    [Symbol.dispose](): void;
+}
+declare function getAttachedImageFromPath(path: string, kind?: AttachedImage["kind"], description?: string): Promise<AttachedImage>;
 
-export { Audiobook };
+export { AAC_FILE_EXTENSIONS, AIFF_FILE_EXTENSIONS, ALAC_FILE_EXTENSIONS, Audiobook, type AudiobookInputs, type AudiobookMetadata, 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 };