@storyteller-platform/audiobook 0.1.0 → 0.2.0

package/dist/bufferEntry.cjs

@@ -0,0 +1,59 @@
+"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 bufferEntry_exports = {};
+__export(bufferEntry_exports, {
+  BufferEntry: () => BufferEntry
+});
+module.exports = __toCommonJS(bufferEntry_exports);
+var import_promises = require("node:fs/promises");
+var import_mediabunny = require("mediabunny");
+var import_entry = require("./entry.cjs");
+var import_ffmpeg = require("./ffmpeg.cjs");
+class BufferEntry extends import_entry.AudiobookEntry {
+  constructor(entry) {
+    super();
+    this.entry = entry;
+    this.filename = entry.filename;
+  }
+  input = null;
+  filename;
+  getInput() {
+    this.input ??= new import_mediabunny.Input({
+      formats: import_mediabunny.ALL_FORMATS,
+      source: new import_mediabunny.BufferSource(this.entry.data)
+    });
+    return this.input;
+  }
+  async getChapters() {
+    const chapters = await (0, import_ffmpeg.getTrackChaptersFromBuffer)(this.entry.data);
+    return chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const { data, filename } = await this.getArrayAndClose();
+    await (0, import_promises.writeFile)(filename, data);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BufferEntry
+});

package/dist/bufferEntry.d.cts

@@ -0,0 +1,16 @@
+import * as mediabunny from 'mediabunny';
+import { Input } from 'mediabunny';
+import { AudiobookEntry, Uint8ArrayEntry } from './entry.cjs';
+import { AudiobookChapter } from './resources.cjs';
+
+declare class BufferEntry extends AudiobookEntry {
+    private entry;
+    private input;
+    filename: string;
+    constructor(entry: Uint8ArrayEntry);
+    getInput(): Input<mediabunny.Source>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    saveAndClose(): Promise<void>;
+}
+
+export { BufferEntry };

package/dist/bufferEntry.d.ts

@@ -0,0 +1,16 @@
+import * as mediabunny from 'mediabunny';
+import { Input } from 'mediabunny';
+import { AudiobookEntry, Uint8ArrayEntry } from './entry.js';
+import { AudiobookChapter } from './resources.js';
+
+declare class BufferEntry extends AudiobookEntry {
+    private entry;
+    private input;
+    filename: string;
+    constructor(entry: Uint8ArrayEntry);
+    getInput(): Input<mediabunny.Source>;
+    getChapters(): Promise<AudiobookChapter[]>;
+    saveAndClose(): Promise<void>;
+}
+
+export { BufferEntry };

package/dist/bufferEntry.js

@@ -0,0 +1,35 @@
+import { writeFile } from "node:fs/promises";
+import { ALL_FORMATS, BufferSource, Input } from "mediabunny";
+import { AudiobookEntry } from "./entry.js";
+import { getTrackChaptersFromBuffer } from "./ffmpeg.js";
+class BufferEntry extends AudiobookEntry {
+  constructor(entry) {
+    super();
+    this.entry = entry;
+    this.filename = entry.filename;
+  }
+  input = null;
+  filename;
+  getInput() {
+    this.input ??= new Input({
+      formats: ALL_FORMATS,
+      source: new BufferSource(this.entry.data)
+    });
+    return this.input;
+  }
+  async getChapters() {
+    const chapters = await getTrackChaptersFromBuffer(this.entry.data);
+    return chapters.map((chapter) => ({
+      filename: this.filename,
+      title: chapter.title,
+      start: chapter.startTime
+    }));
+  }
+  async saveAndClose() {
+    const { data, filename } = await this.getArrayAndClose();
+    await writeFile(filename, data);
+  }
+}
+export {
+  BufferEntry
+};

package/dist/entry.cjs

@@ -21,34 +21,265 @@ __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_mediabunny = require("mediabunny");
+var import_tagMaps = require("./tagMaps.cjs");
+function splitNames(names) {
+  return names.split(/[;,/]/).map((name) => name.trim());
+}
+class AudiobookEntry {
+  metadataTags = null;
+  duration = null;
+  async getMetadataTags() {
+    if (this.metadataTags) return this.metadataTags;
+    const input = await this.getInput();
+    this.metadataTags = await input.getMetadataTags();
+    return this.metadataTags;
+  }
+  async getOutputFormat() {
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    switch (inputFormat) {
+      case import_mediabunny.MP3: {
+        return new import_mediabunny.Mp3OutputFormat();
+      }
+      case import_mediabunny.MP4: {
+        return new import_mediabunny.Mp4OutputFormat();
+      }
+      case import_mediabunny.WAVE: {
+        return new import_mediabunny.WavOutputFormat();
+      }
+      case import_mediabunny.OGG: {
+        return new import_mediabunny.OggOutputFormat();
+      }
+      case import_mediabunny.FLAC: {
+        return new import_mediabunny.FlacOutputFormat();
+      }
+    }
+    return null;
+  }
+  async getTitle() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const tag of import_tagMaps.readTagMap.title) {
+      if (typeof tags.raw[tag] === "string") {
+        return tags.raw[tag];
+      }
+    }
+    return null;
+  }
+  async getTrackTitle() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const tag of import_tagMaps.readTagMap.trackTitle) {
+      if (typeof tags.raw[tag] === "string") {
+        return tags.raw[tag];
+      }
+    }
+    return null;
+  }
+  async setTitle(title) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "title");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = title;
+    }
+  }
+  async getSubtitle() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const subtitleTag of import_tagMaps.readTagMap.subtitle) {
+      if (typeof tags.raw[subtitleTag] === "string") {
+        return tags.raw[subtitleTag];
+      }
+    }
+    return null;
+  }
+  async setSubtitle(subtitle) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "subtitle");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = subtitle;
+    }
+  }
+  async getDescription() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const tag of import_tagMaps.readTagMap.description) {
+      if (typeof tags.raw[tag] === "string") {
+        return tags.raw[tag];
+      }
+    }
+    return null;
+  }
+  async setDescription(description) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "description");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = description;
+    }
+  }
+  async getAuthors() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return [];
+    for (const tag of import_tagMaps.readTagMap.authors) {
+      if (typeof tags.raw[tag] === "string") {
+        return splitNames(tags.raw[tag]);
+      }
+    }
+    return [];
+  }
+  async setAuthors(authors) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "authors");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = authors.join(";");
+    }
+  }
+  async getNarrators() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return [];
+    for (const tag of import_tagMaps.readTagMap.narrators) {
+      if (typeof tags.raw[tag] === "string") {
+        return splitNames(tags.raw[tag]);
+      }
+    }
+    return [];
+  }
+  async setNarrators(narrators) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "narrators");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = narrators.join(";");
+    }
+  }
+  async getCoverArt() {
+    var _a;
+    const tags = await this.getMetadataTags();
+    return ((_a = tags.images) == null ? void 0 : _a.find((image) => image.kind === "coverFront")) ?? null;
+  }
+  async setCoverArt(picture) {
+    const tags = await this.getMetadataTags();
+    const images = tags.images ?? [];
+    const frontCover = images.find((image) => image.kind === "coverFront");
+    if (frontCover) {
+      Object.assign(frontCover, picture);
+    } else {
+      images.push(picture);
+    }
+    tags.images = images;
+  }
+  async getPublisher() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const tag of import_tagMaps.readTagMap.publisher) {
+      if (typeof tags.raw[tag] === "string") {
+        return tags.raw[tag];
+      }
+    }
+    return null;
+  }
+  async setPublisher(publisher) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "publisher");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = publisher;
+    }
+  }
+  async getReleaseDate() {
+    const tags = await this.getMetadataTags();
+    if (!tags.raw) return null;
+    for (const tag of import_tagMaps.readTagMap.releaseDate) {
+      if (typeof tags.raw[tag] === "string") {
+        return new Date(tags.raw[tag]);
+      }
+    }
+    return null;
+  }
+  async setReleaseDate(date) {
+    const tags = await this.getMetadataTags();
+    const input = await this.getInput();
+    const inputFormat = await input.getFormat();
+    const writeTags = (0, import_tagMaps.getWriteTags)(inputFormat, "releaseDate");
+    tags.raw ??= {};
+    for (const tag of writeTags) {
+      tags.raw[tag] = `${date.getDate().toString().padStart(2, "0")}-${date.getMonth().toString().padStart(2, "0")}-${date.getFullYear()}`;
+    }
+  }
+  async getDuration() {
+    const input = await this.getInput();
+    this.duration ??= await input.computeDuration();
+    return this.duration;
+  }
+  async getResource() {
+    const input = await this.getInput();
+    this.duration ??= await input.computeDuration();
+    const title = await this.getTrackTitle() ?? null;
+    const type = await input.getMimeType();
+    return {
+      filename: this.filename,
+      title,
+      type,
+      duration: this.duration,
+      bitrate: null
+    };
+  }
+  async getArrayAndClose() {
+    const input = await this.getInput();
+    const outputFormat = await this.getOutputFormat();
+    if (!outputFormat) {
+      const inputFormat = await input.getFormat();
+      throw new Error(
+        `Failed to save Audiobook entry: could not find valid output format for input with format ${inputFormat.name}`
+      );
+    }
+    const output = new import_mediabunny.Output({
+      format: outputFormat,
+      target: new import_mediabunny.BufferTarget()
+    });
+    const tags = await this.getMetadataTags();
+    const conversion = await import_mediabunny.Conversion.init({
+      input,
+      output,
+      tags: {
+        // Since we only write raw metadata tags, we
+        // only copy those into the output. Otherwise
+        // the unchanged parsed metadata tags will overwrite
+        // our changes to raw!
+        raw: tags.raw ?? {},
+        images: tags.images ?? []
+      },
+      showWarnings: false
+    });
+    if (!conversion.isValid) {
+      throw new Error(
+        conversion.discardedTracks.map((track) => track.reason).join(";")
+      );
+    }
+    await conversion.execute();
+    input.dispose();
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      data: new Uint8Array(output.target.buffer),
+      filename: this.filename
+    };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/entry.d.cts

@@ -1,19 +1,39 @@
-import { Entry } from '@zip.js/zip.js';
-import { File } from 'node-taglib-sharp';
-import { BaseAudiobookEntry } from './base.cjs';
+import { Input, MetadataTags, OutputFormat, AttachedImage } from 'mediabunny';
+import { AudiobookChapter, AudiobookResource } from './resources.cjs';
 
 interface Uint8ArrayEntry {
     filename: string;
     data: Uint8Array;
 }
-declare class AudiobookEntry extends BaseAudiobookEntry {
-    protected entry: Uint8ArrayEntry | Entry;
-    filename: string;
-    protected file: File | null;
-    protected readData(): Promise<Uint8Array<ArrayBufferLike>>;
-    getData(): Promise<Uint8Array<ArrayBufferLike>>;
-    createFile(): Promise<File>;
-    constructor(entry: Uint8ArrayEntry | Entry);
+declare abstract class AudiobookEntry {
+    abstract filename: string;
+    private metadataTags;
+    private duration;
+    abstract getChapters(): Promise<AudiobookChapter[]>;
+    abstract getInput(): Promise<Input> | Input;
+    abstract saveAndClose(): Promise<void>;
+    getMetadataTags(): Promise<MetadataTags>;
+    getOutputFormat(): Promise<OutputFormat | null>;
+    getTitle(): Promise<string | null>;
+    getTrackTitle(): 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>;
+    getResource(): Promise<AudiobookResource>;
+    getArrayAndClose(): Promise<Uint8ArrayEntry>;
 }
 
 export { AudiobookEntry, type Uint8ArrayEntry };

package/dist/entry.d.ts

@@ -1,19 +1,39 @@
-import { Entry } from '@zip.js/zip.js';
-import { File } from 'node-taglib-sharp';
-import { BaseAudiobookEntry } from './base.js';
+import { Input, MetadataTags, OutputFormat, AttachedImage } from 'mediabunny';
+import { AudiobookChapter, AudiobookResource } from './resources.js';
 
 interface Uint8ArrayEntry {
     filename: string;
     data: Uint8Array;
 }
-declare class AudiobookEntry extends BaseAudiobookEntry {
-    protected entry: Uint8ArrayEntry | Entry;
-    filename: string;
-    protected file: File | null;
-    protected readData(): Promise<Uint8Array<ArrayBufferLike>>;
-    getData(): Promise<Uint8Array<ArrayBufferLike>>;
-    createFile(): Promise<File>;
-    constructor(entry: Uint8ArrayEntry | Entry);
+declare abstract class AudiobookEntry {
+    abstract filename: string;
+    private metadataTags;
+    private duration;
+    abstract getChapters(): Promise<AudiobookChapter[]>;
+    abstract getInput(): Promise<Input> | Input;
+    abstract saveAndClose(): Promise<void>;
+    getMetadataTags(): Promise<MetadataTags>;
+    getOutputFormat(): Promise<OutputFormat | null>;
+    getTitle(): Promise<string | null>;
+    getTrackTitle(): 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>;
+    getResource(): Promise<AudiobookResource>;
+    getArrayAndClose(): Promise<Uint8ArrayEntry>;
 }
 
 export { AudiobookEntry, type Uint8ArrayEntry };