@storyteller-platform/audiobook 0.1.0

package/dist/entry.js

@@ -0,0 +1,33 @@
+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)
+    );
+  }
+}
+export {
+  AudiobookEntry
+};

package/dist/index.cjs

@@ -0,0 +1,69 @@
+"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 index_exports = {};
+__export(index_exports, {
+  Audiobook: () => Audiobook
+});
+module.exports = __toCommonJS(index_exports);
+var import_zip = require("@zip.js/zip.js");
+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)]);
+    }
+    return new Audiobook(
+      pathOrPathsOrData.map((path) => new import_entry.AudiobookEntry(path))
+    );
+  }
+  static create(metadata) {
+    const audiobook = new Audiobook([]);
+    audiobook.metadata = metadata;
+    return audiobook;
+  }
+  async save() {
+    for (const entry of this.entries) {
+      entry.save();
+    }
+    return await Promise.all(
+      this.entries.map(async (entry) => ({
+        filename: entry.filename,
+        data: await entry.getData()
+      }))
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Audiobook
+});

package/dist/index.d.cts

@@ -0,0 +1,14 @@
+import { BaseAudiobook, AudiobookMetadata } from './base.cjs';
+import { AudiobookEntry, Uint8ArrayEntry } from './entry.cjs';
+import 'node-taglib-sharp';
+import '@zip.js/zip.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[]>;
+}
+
+export { Audiobook };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { BaseAudiobook, AudiobookMetadata } from './base.js';
+import { AudiobookEntry, Uint8ArrayEntry } from './entry.js';
+import 'node-taglib-sharp';
+import '@zip.js/zip.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[]>;
+}
+
+export { Audiobook };

package/dist/index.js

@@ -0,0 +1,45 @@
+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)]);
+    }
+    return new Audiobook(
+      pathOrPathsOrData.map((path) => new AudiobookEntry(path))
+    );
+  }
+  static create(metadata) {
+    const audiobook = new Audiobook([]);
+    audiobook.metadata = metadata;
+    return audiobook;
+  }
+  async save() {
+    for (const entry of this.entries) {
+      entry.save();
+    }
+    return await Promise.all(
+      this.entries.map(async (entry) => ({
+        filename: entry.filename,
+        data: await entry.getData()
+      }))
+    );
+  }
+}
+export {
+  Audiobook
+};

package/dist/node/entry.cjs

@@ -0,0 +1,76 @@
+"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 entry_exports = {};
+__export(entry_exports, {
+  AudiobookEntry: () => AudiobookEntry
+});
+module.exports = __toCommonJS(entry_exports);
+var import_promises = require("node:fs/promises");
+var import_zip = require("@zip.js/zip.js");
+var import_node_taglib_sharp = require("node-taglib-sharp");
+var import_fs = require("@storyteller-platform/fs");
+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 = typeof entry === "string" ? entry : entry.filename;
+  }
+  filename;
+  file = null;
+  async createFile() {
+    if (typeof this.entry === "string") {
+      const file = import_node_taglib_sharp.File.createFromPath(this.entry);
+      return file;
+    }
+    const data = await this.readData();
+    return import_node_taglib_sharp.File.createFromAbstraction(
+      new import_Uint8ArrayFileAbstraction.Uint8ArrayFileAbstraction(this.filename, data)
+    );
+  }
+  async getData() {
+    if (typeof this.entry === "string") {
+      return await (0, import_promises.readFile)(this.entry);
+    }
+    const file = await this.getFile();
+    return file.fileAbstraction.data;
+  }
+  async readData() {
+    if (typeof this.entry === "string") {
+      return await (0, import_fs.streamFile)(this.entry);
+    }
+    if ("data" in this.entry) {
+      return this.entry.data;
+    }
+    const writer = new import_zip.Uint8ArrayWriter();
+    return await this.entry.getData(writer);
+  }
+  persisted() {
+    return typeof this.entry === "string";
+  }
+  close() {
+    var _a;
+    (_a = this.file) == null ? void 0 : _a.dispose();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudiobookEntry
+});

package/dist/node/entry.d.cts

@@ -0,0 +1,18 @@
+import { Entry } from '@zip.js/zip.js';
+import { File } from 'node-taglib-sharp';
+import { BaseAudiobookEntry } from '../base.cjs';
+import { Uint8ArrayEntry } from '../entry.cjs';
+
+declare class AudiobookEntry extends BaseAudiobookEntry {
+    protected entry: string | Uint8ArrayEntry | Entry;
+    filename: string;
+    protected file: File | null;
+    constructor(entry: string | Uint8ArrayEntry | Entry);
+    createFile(): Promise<File>;
+    getData(): Promise<Uint8Array>;
+    protected readData(): Promise<Uint8Array>;
+    persisted(): boolean;
+    close(): void;
+}
+
+export { AudiobookEntry };

package/dist/node/entry.d.ts

@@ -0,0 +1,18 @@
+import { Entry } from '@zip.js/zip.js';
+import { File } from 'node-taglib-sharp';
+import { BaseAudiobookEntry } from '../base.js';
+import { Uint8ArrayEntry } from '../entry.js';
+
+declare class AudiobookEntry extends BaseAudiobookEntry {
+    protected entry: string | Uint8ArrayEntry | Entry;
+    filename: string;
+    protected file: File | null;
+    constructor(entry: string | Uint8ArrayEntry | Entry);
+    createFile(): Promise<File>;
+    getData(): Promise<Uint8Array>;
+    protected readData(): Promise<Uint8Array>;
+    persisted(): boolean;
+    close(): void;
+}
+
+export { AudiobookEntry };

package/dist/node/entry.js

@@ -0,0 +1,52 @@
+import { readFile } from "node:fs/promises";
+import { Uint8ArrayWriter } from "@zip.js/zip.js";
+import { File } from "node-taglib-sharp";
+import { streamFile } from "@storyteller-platform/fs";
+import { BaseAudiobookEntry } from "../base.js";
+import { Uint8ArrayFileAbstraction } from "../taglib/Uint8ArrayFileAbstraction.js";
+class AudiobookEntry extends BaseAudiobookEntry {
+  constructor(entry) {
+    super();
+    this.entry = entry;
+    this.filename = typeof entry === "string" ? entry : entry.filename;
+  }
+  filename;
+  file = null;
+  async createFile() {
+    if (typeof this.entry === "string") {
+      const file = File.createFromPath(this.entry);
+      return file;
+    }
+    const data = await this.readData();
+    return File.createFromAbstraction(
+      new Uint8ArrayFileAbstraction(this.filename, data)
+    );
+  }
+  async getData() {
+    if (typeof this.entry === "string") {
+      return await readFile(this.entry);
+    }
+    const file = await this.getFile();
+    return file.fileAbstraction.data;
+  }
+  async readData() {
+    if (typeof this.entry === "string") {
+      return await streamFile(this.entry);
+    }
+    if ("data" in this.entry) {
+      return this.entry.data;
+    }
+    const writer = new Uint8ArrayWriter();
+    return await this.entry.getData(writer);
+  }
+  persisted() {
+    return typeof this.entry === "string";
+  }
+  close() {
+    var _a;
+    (_a = this.file) == null ? void 0 : _a.dispose();
+  }
+}
+export {
+  AudiobookEntry
+};

package/dist/node/index.cjs

@@ -0,0 +1,107 @@
+"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 node_exports = {};
+__export(node_exports, {
+  Audiobook: () => Audiobook
+});
+module.exports = __toCommonJS(node_exports);
+var import_promises = require("node:fs/promises");
+var import_zip = require("@zip.js/zip.js");
+var import_node_taglib_sharp = require("node-taglib-sharp");
+var import_fs = require("@storyteller-platform/fs");
+var import_path = require("@storyteller-platform/path");
+var import_base = require("../base.cjs");
+var import_entry2 = require("./entry.cjs");
+class Audiobook extends import_base.BaseAudiobook {
+  constructor(entries, zipPath) {
+    super();
+    this.entries = entries;
+    this.zipPath = zipPath;
+  }
+  static async from(pathOrPathsOrData) {
+    if (Array.isArray(pathOrPathsOrData)) {
+      return new Audiobook(
+        pathOrPathsOrData.map((path) => new import_entry2.AudiobookEntry(path))
+      );
+    }
+    const filepath = typeof pathOrPathsOrData === "string" ? pathOrPathsOrData : pathOrPathsOrData.filename;
+    const ext = (0, import_path.extname)(filepath);
+    if (ext === ".zip") {
+      const dataReader = new import_zip.Uint8ArrayReader(
+        typeof pathOrPathsOrData === "string" ? await (0, import_fs.streamFile)(pathOrPathsOrData) : pathOrPathsOrData.data
+      );
+      const zipReader = new import_zip.ZipReader(dataReader);
+      const zipEntries = await zipReader.getEntries();
+      const entries = zipEntries.map((entry) => new import_entry2.AudiobookEntry(entry));
+      return new Audiobook(entries, filepath);
+    }
+    return new Audiobook([new import_entry2.AudiobookEntry(pathOrPathsOrData)]);
+  }
+  async save() {
+    const result = [];
+    for (const entry of this.entries) {
+      entry.save();
+      if (!entry.persisted()) {
+        result.push({ filename: entry.filename, data: await entry.getData() });
+      }
+    }
+    if (this.zipPath) {
+      const dataWriter = new import_zip.Uint8ArrayWriter();
+      const zipWriter = new import_zip.ZipWriter(dataWriter);
+      await Promise.all(
+        this.entries.map(async (entry) => {
+          const data2 = await entry.getData();
+          const reader = new import_zip.Uint8ArrayReader(data2);
+          try {
+            return await zipWriter.add(entry.filename, reader);
+          } catch (e) {
+            if (e instanceof Error && e.message === import_zip.ERR_DUPLICATED_NAME) {
+              throw new Error(
+                `Failed to add file "${entry.filename}" to zip archive: ${e.message}`
+              );
+            }
+            throw e;
+          }
+        })
+      );
+      const data = await zipWriter.close();
+      await (0, import_promises.writeFile)(this.zipPath, data);
+      return;
+    }
+    if (result.length) return result;
+    return void 0;
+  }
+  async setCoverArt(picture) {
+    if (typeof picture === "string") {
+      const filename = (0, import_path.basename)(picture);
+      picture = import_node_taglib_sharp.Picture.fromPath(picture);
+      picture.filename = filename;
+    }
+    return super.setCoverArt(picture);
+  }
+  close() {
+    for (const entry of this.entries) {
+      entry.close();
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Audiobook
+});

package/dist/node/index.d.cts

@@ -0,0 +1,17 @@
+import { IPicture } from 'node-taglib-sharp';
+import { BaseAudiobook } from '../base.cjs';
+import { Uint8ArrayEntry } from '../entry.cjs';
+import { AudiobookEntry } from './entry.cjs';
+import '@zip.js/zip.js';
+
+declare class Audiobook extends BaseAudiobook {
+    protected entries: AudiobookEntry[];
+    protected zipPath?: string | undefined;
+    protected constructor(entries: AudiobookEntry[], zipPath?: string | undefined);
+    static from(pathOrPathsOrData: string | string[] | Uint8ArrayEntry | Uint8ArrayEntry[]): Promise<Audiobook>;
+    save(): Promise<Uint8ArrayEntry[] | undefined>;
+    setCoverArt(picture: string | IPicture): Promise<void>;
+    close(): void;
+}
+
+export { Audiobook };

package/dist/node/index.d.ts

@@ -0,0 +1,17 @@
+import { IPicture } from 'node-taglib-sharp';
+import { BaseAudiobook } from '../base.js';
+import { Uint8ArrayEntry } from '../entry.js';
+import { AudiobookEntry } from './entry.js';
+import '@zip.js/zip.js';
+
+declare class Audiobook extends BaseAudiobook {
+    protected entries: AudiobookEntry[];
+    protected zipPath?: string | undefined;
+    protected constructor(entries: AudiobookEntry[], zipPath?: string | undefined);
+    static from(pathOrPathsOrData: string | string[] | Uint8ArrayEntry | Uint8ArrayEntry[]): Promise<Audiobook>;
+    save(): Promise<Uint8ArrayEntry[] | undefined>;
+    setCoverArt(picture: string | IPicture): Promise<void>;
+    close(): void;
+}
+
+export { Audiobook };

package/dist/node/index.js

@@ -0,0 +1,89 @@
+import { writeFile } from "node:fs/promises";
+import {
+  ERR_DUPLICATED_NAME,
+  Uint8ArrayReader,
+  Uint8ArrayWriter,
+  ZipReader,
+  ZipWriter
+} from "@zip.js/zip.js";
+import { Picture } from "node-taglib-sharp";
+import { streamFile } from "@storyteller-platform/fs";
+import { basename, extname } from "@storyteller-platform/path";
+import { BaseAudiobook } from "../base.js";
+import { AudiobookEntry } from "./entry.js";
+class Audiobook extends BaseAudiobook {
+  constructor(entries, zipPath) {
+    super();
+    this.entries = entries;
+    this.zipPath = zipPath;
+  }
+  static async from(pathOrPathsOrData) {
+    if (Array.isArray(pathOrPathsOrData)) {
+      return new Audiobook(
+        pathOrPathsOrData.map((path) => new AudiobookEntry(path))
+      );
+    }
+    const filepath = typeof pathOrPathsOrData === "string" ? pathOrPathsOrData : pathOrPathsOrData.filename;
+    const ext = extname(filepath);
+    if (ext === ".zip") {
+      const dataReader = new Uint8ArrayReader(
+        typeof pathOrPathsOrData === "string" ? await streamFile(pathOrPathsOrData) : pathOrPathsOrData.data
+      );
+      const zipReader = new ZipReader(dataReader);
+      const zipEntries = await zipReader.getEntries();
+      const entries = zipEntries.map((entry) => new AudiobookEntry(entry));
+      return new Audiobook(entries, filepath);
+    }
+    return new Audiobook([new AudiobookEntry(pathOrPathsOrData)]);
+  }
+  async save() {
+    const result = [];
+    for (const entry of this.entries) {
+      entry.save();
+      if (!entry.persisted()) {
+        result.push({ filename: entry.filename, data: await entry.getData() });
+      }
+    }
+    if (this.zipPath) {
+      const dataWriter = new Uint8ArrayWriter();
+      const zipWriter = new ZipWriter(dataWriter);
+      await Promise.all(
+        this.entries.map(async (entry) => {
+          const data2 = await entry.getData();
+          const reader = new Uint8ArrayReader(data2);
+          try {
+            return await zipWriter.add(entry.filename, reader);
+          } catch (e) {
+            if (e instanceof Error && e.message === ERR_DUPLICATED_NAME) {
+              throw new Error(
+                `Failed to add file "${entry.filename}" to zip archive: ${e.message}`
+              );
+            }
+            throw e;
+          }
+        })
+      );
+      const data = await zipWriter.close();
+      await writeFile(this.zipPath, data);
+      return;
+    }
+    if (result.length) return result;
+    return void 0;
+  }
+  async setCoverArt(picture) {
+    if (typeof picture === "string") {
+      const filename = basename(picture);
+      picture = Picture.fromPath(picture);
+      picture.filename = filename;
+    }
+    return super.setCoverArt(picture);
+  }
+  close() {
+    for (const entry of this.entries) {
+      entry.close();
+    }
+  }
+}
+export {
+  Audiobook
+};