@soga/mediainfo 0.4.0 → 0.5.0

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+declare function parseMediaRaw(media_path: string): Promise<any>;
+declare function parseMediaInfo(media_path: string): Promise<{
+    audio: AudioTrackInfo[];
+    video: VideoTrackInfo[];
+    text: TextTrackInfo[];
+    general: GeneralInfo;
+}>;
+type GeneralInfo = {
+    audioCount: number;
+    videoCount: number;
+    textCount: number;
+    fileSize: number;
+    codec: string;
+    title: string;
+    duration: number;
+    extra?: {
+        duration: string;
+    };
+};
+type AudioTrackInfo = {
+    is_default: boolean;
+    order: number;
+    codec: string;
+    bitrate: number;
+    framerate: number;
+    sample_rate: number;
+    channels: number;
+    duration: number;
+    lossless: boolean;
+};
+type VideoTrackInfo = {
+    is_default: boolean;
+    order: number;
+    width: number;
+    height: number;
+    codec: string;
+    profile: string;
+    framerate: number;
+    bitrate: number;
+    duration: number;
+    bitdepth: number;
+    format_profile: string;
+    format_tier: string;
+};
+type TextTrackInfo = {
+    is_default: boolean;
+    codec: string;
+    order: number;
+    duration: number;
+    language?: string;
+    title?: string;
+    is_vtt?: boolean;
+};
+type Mediainfo = {
+    general?: GeneralInfo;
+    audio?: AudioTrackInfo[];
+    video?: VideoTrackInfo[];
+    text?: TextTrackInfo[];
+};
+
+export { type AudioTrackInfo, type GeneralInfo, type Mediainfo, type TextTrackInfo, type VideoTrackInfo, parseMediaInfo, parseMediaRaw };

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+declare function parseMediaRaw(media_path: string): Promise<any>;
+declare function parseMediaInfo(media_path: string): Promise<{
+    audio: AudioTrackInfo[];
+    video: VideoTrackInfo[];
+    text: TextTrackInfo[];
+    general: GeneralInfo;
+}>;
+type GeneralInfo = {
+    audioCount: number;
+    videoCount: number;
+    textCount: number;
+    fileSize: number;
+    codec: string;
+    title: string;
+    duration: number;
+    extra?: {
+        duration: string;
+    };
+};
+type AudioTrackInfo = {
+    is_default: boolean;
+    order: number;
+    codec: string;
+    bitrate: number;
+    framerate: number;
+    sample_rate: number;
+    channels: number;
+    duration: number;
+    lossless: boolean;
+};
+type VideoTrackInfo = {
+    is_default: boolean;
+    order: number;
+    width: number;
+    height: number;
+    codec: string;
+    profile: string;
+    framerate: number;
+    bitrate: number;
+    duration: number;
+    bitdepth: number;
+    format_profile: string;
+    format_tier: string;
+};
+type TextTrackInfo = {
+    is_default: boolean;
+    codec: string;
+    order: number;
+    duration: number;
+    language?: string;
+    title?: string;
+    is_vtt?: boolean;
+};
+type Mediainfo = {
+    general?: GeneralInfo;
+    audio?: AudioTrackInfo[];
+    video?: VideoTrackInfo[];
+    text?: TextTrackInfo[];
+};
+
+export { type AudioTrackInfo, type GeneralInfo, type Mediainfo, type TextTrackInfo, type VideoTrackInfo, parseMediaInfo, parseMediaRaw };

package/dist/index.js

@@ -0,0 +1,200 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseMediaInfo: () => parseMediaInfo,
+  parseMediaRaw: () => parseMediaRaw
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs_extra = require("fs-extra");
+var import_promises = require("fs/promises");
+var import_mediainfo = __toESM(require("mediainfo.js"));
+async function parseMediaRaw(media_path) {
+  const mediainfo = await (0, import_mediainfo.default)({
+    format: "JSON"
+  });
+  const fileList = typeof media_path === "string" ? [media_path] : media_path;
+  let total = 0;
+  const arr = [];
+  for await (const [index, file_path] of fileList.entries()) {
+    const { size } = await (0, import_promises.stat)(file_path);
+    arr.push({
+      index,
+      start: total,
+      end: total + size - 1,
+      size,
+      file_path
+    });
+    total += size;
+  }
+  const getBuffer = async (size, offset) => {
+    if (!size) {
+      return new Uint8Array(0);
+    }
+    const start = offset;
+    const end = offset + size - 1;
+    const first = arr.find((item) => item.start <= start && item.end >= start);
+    const last = arr.find((item) => item.start <= end && item.end >= end);
+    if (!first || !last) {
+      return new Uint8Array(0);
+    }
+    const list = [];
+    if (first.index === last.index) {
+      list.push({
+        index: first.index,
+        file_path: first.file_path,
+        from: start - first.start,
+        to: end - first.start
+      });
+    } else {
+      list.push({
+        index: first.index,
+        file_path: first.file_path,
+        from: start - first.start,
+        to: first.end
+      });
+      for (let i = first.index + 1; i < last.index; i++) {
+        const item = arr[i];
+        if (item) {
+          list.push({
+            index: item.index,
+            file_path: item.file_path,
+            from: 0,
+            to: item.size - 1
+          });
+        }
+      }
+      list.push({
+        index: last.index,
+        file_path: last.file_path,
+        from: 0,
+        to: end - last.start
+      });
+    }
+    const buffers = [];
+    for await (const item of list) {
+      const { file_path, from, to } = item;
+      const stream = (0, import_fs_extra.createReadStream)(file_path, { start: from, end: to });
+      for await (const data2 of stream) {
+        buffers.push(data2);
+      }
+      stream.close();
+    }
+    const buffer = Buffer.concat(buffers);
+    return buffer;
+  };
+  const data = await mediainfo.analyzeData(() => total, getBuffer);
+  try {
+    const rawJson = JSON.parse(data);
+    return rawJson;
+  } catch (err) {
+    const text = data.replace(',"":{}]}]}', ',"":{}}]}');
+    const rawJson = JSON.parse(text);
+    return rawJson;
+  }
+}
+async function parseMediaInfo(media_path) {
+  const raw = await parseMediaRaw(media_path);
+  const rawMediainfo = raw.media;
+  const list = rawMediainfo.track;
+  const info = {
+    audio: [],
+    video: [],
+    text: [],
+    general: {}
+  };
+  let audioOrder = 0;
+  let videoOrder = 0;
+  let textOrder = 0;
+  list.forEach((item) => {
+    const type = item["@type"];
+    if (type === "Audio") {
+      info.audio.push({
+        is_default: item.Default === "Yes",
+        codec: item.Format.toLowerCase(),
+        // order: Number(item.StreamOrder),
+        order: audioOrder++,
+        // size: Number(item.StreamSize),
+        bitrate: Number(item.BitRate),
+        framerate: Number(item.FrameRate),
+        sample_rate: Number(item.SamplingRate),
+        duration: Number(item.Duration),
+        channels: Number(item.Channels),
+        lossless: item.Compression_Mode === "Lossless"
+      });
+    } else if (type === "Text") {
+      info.text.push({
+        is_default: item.Default === "Yes",
+        codec: item.Format.toLowerCase(),
+        // order: Number(item.StreamOrder),
+        order: textOrder++,
+        duration: Number(item.Duration),
+        title: item.Title || item.Language,
+        language: item.Language
+      });
+    } else if (type === "Video") {
+      info.video.push({
+        is_default: item.Default === "Yes",
+        codec: item.Format.toLowerCase(),
+        order: videoOrder++,
+        width: Number(item.Width),
+        height: Number(item.Height),
+        profile: item.Format_Profile,
+        bitrate: Number(item.BitRate),
+        framerate: Number(item.FrameRate) ? Math.round(Number(item.FrameRate)) : 0,
+        // sample_rate: Number(item.SamplingRate),
+        duration: Number(item.Duration),
+        bitdepth: Number(item.BitDepth),
+        format_profile: item.Format_Profile,
+        format_tier: item.Format_Tier
+      });
+    } else if (type === "General") {
+      info.general = {
+        audioCount: Number(item.AudioCount),
+        textCount: Number(item.TextCount) || 0,
+        videoCount: Number(item.VideoCount),
+        fileSize: Number(item.FileSize),
+        title: item.Title || "",
+        duration: Number(item.Duration),
+        codec: item.Format
+      };
+      if (!info.general.duration && item.extra?.duration) {
+        info.general.duration = Number(item.extra.duration);
+      }
+    }
+  });
+  return info;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseMediaInfo,
+  parseMediaRaw
+});

package/{src/index.ts → dist/index.mjs}

@@ -1,20 +1,14 @@
+// src/index.ts
 import { createReadStream } from "fs-extra";
 import { stat } from "fs/promises";
-import getMediainfo, { FormatType, MediaInfo } from "mediainfo.js";
-
-export async function parseMediaRaw(media_path: string) {
-  const mediainfo: MediaInfo<FormatType> = await getMediainfo({
-    format: "JSON" as FormatType,
+import getMediainfo from "mediainfo.js";
+async function parseMediaRaw(media_path) {
+  const mediainfo = await getMediainfo({
+    format: "JSON"
   });
   const fileList = typeof media_path === "string" ? [media_path] : media_path;
   let total = 0;
-  const arr = [] as {
-    index: number;
-    start: number;
-    end: number;
-    size: number;
-    file_path: string;
-  }[];
+  const arr = [];
   for await (const [index, file_path] of fileList.entries()) {
     const { size } = await stat(file_path);
     arr.push({
@@ -22,12 +16,11 @@ export async function parseMediaRaw(media_path: string) {
       start: total,
       end: total + size - 1,
       size,
-      file_path,
+      file_path
     });
     total += size;
   }
-
-  const getBuffer = async (size: number, offset: number) => {
+  const getBuffer = async (size, offset) => {
     if (!size) {
       return new Uint8Array(0);
     }
@@ -38,26 +31,20 @@ export async function parseMediaRaw(media_path: string) {
     if (!first || !last) {
       return new Uint8Array(0);
     }
-
-    const list = [] as {
-      index: number;
-      file_path: string;
-      from: number;
-      to: number;
-    }[];
+    const list = [];
     if (first.index === last.index) {
       list.push({
         index: first.index,
         file_path: first.file_path,
         from: start - first.start,
-        to: end - first.start,
+        to: end - first.start
       });
     } else {
       list.push({
         index: first.index,
         file_path: first.file_path,
         from: start - first.start,
-        to: first.end,
+        to: first.end
       });
       for (let i = first.index + 1; i < last.index; i++) {
         const item = arr[i];
@@ -66,7 +53,7 @@ export async function parseMediaRaw(media_path: string) {
             index: item.index,
             file_path: item.file_path,
             from: 0,
-            to: item.size - 1,
+            to: item.size - 1
           });
         }
       }
@@ -74,15 +61,15 @@ export async function parseMediaRaw(media_path: string) {
         index: last.index,
         file_path: last.file_path,
         from: 0,
-        to: end - last.start,
+        to: end - last.start
       });
     }
-    const buffers = [] as Buffer[];
+    const buffers = [];
     for await (const item of list) {
       const { file_path, from, to } = item;
       const stream = createReadStream(file_path, { start: from, end: to });
-      for await (const data of stream) {
-        buffers.push(data);
+      for await (const data2 of stream) {
+        buffers.push(data2);
       }
       stream.close();
     }
@@ -90,35 +77,29 @@ export async function parseMediaRaw(media_path: string) {
     return buffer;
   };
   const data = await mediainfo.analyzeData(() => total, getBuffer);
-
   try {
-    const rawJson = JSON.parse(data as string);
+    const rawJson = JSON.parse(data);
     return rawJson;
   } catch (err) {
-    // const text = (data as string).replace(
-    //   '"Menu","":{}]}]}',
-    //   '"Menu","":{}}]}',
-    // );
-    const text = (data as string).replace(',"":{}]}]}', ',"":{}}]}');
+    const text = data.replace(',"":{}]}]}', ',"":{}}]}');
     const rawJson = JSON.parse(text);
     return rawJson;
   }
 }
-
-export async function parseMediaInfo(media_path: string) {
+async function parseMediaInfo(media_path) {
   const raw = await parseMediaRaw(media_path);
   const rawMediainfo = raw.media;
   const list = rawMediainfo.track;
   const info = {
-    audio: [] as AudioTrackInfo[],
-    video: [] as VideoTrackInfo[],
-    text: [] as TextTrackInfo[],
-    general: {} as GeneralInfo,
+    audio: [],
+    video: [],
+    text: [],
+    general: {}
   };
   let audioOrder = 0;
   let videoOrder = 0;
   let textOrder = 0;
-  list.forEach((item: any) => {
+  list.forEach((item) => {
     const type = item["@type"];
     if (type === "Audio") {
       info.audio.push({
@@ -132,7 +113,7 @@ export async function parseMediaInfo(media_path: string) {
         sample_rate: Number(item.SamplingRate),
         duration: Number(item.Duration),
         channels: Number(item.Channels),
-        lossless: item.Compression_Mode === "Lossless",
+        lossless: item.Compression_Mode === "Lossless"
       });
     } else if (type === "Text") {
       info.text.push({
@@ -142,7 +123,7 @@ export async function parseMediaInfo(media_path: string) {
         order: textOrder++,
         duration: Number(item.Duration),
         title: item.Title || item.Language,
-        language: item.Language,
+        language: item.Language
       });
     } else if (type === "Video") {
       info.video.push({
@@ -153,14 +134,12 @@ export async function parseMediaInfo(media_path: string) {
         height: Number(item.Height),
         profile: item.Format_Profile,
         bitrate: Number(item.BitRate),
-        framerate: Number(item.FrameRate)
-          ? Math.round(Number(item.FrameRate))
-          : 0,
+        framerate: Number(item.FrameRate) ? Math.round(Number(item.FrameRate)) : 0,
         // sample_rate: Number(item.SamplingRate),
         duration: Number(item.Duration),
         bitdepth: Number(item.BitDepth),
         format_profile: item.Format_Profile,
-        format_tier: item.Format_Tier,
+        format_tier: item.Format_Tier
       });
     } else if (type === "General") {
       info.general = {
@@ -170,69 +149,16 @@ export async function parseMediaInfo(media_path: string) {
         fileSize: Number(item.FileSize),
         title: item.Title || "",
         duration: Number(item.Duration),
-        codec: item.Format,
+        codec: item.Format
       };
       if (!info.general.duration && item.extra?.duration) {
         info.general.duration = Number(item.extra.duration);
       }
     }
   });
-
   return info;
 }
-
-export type GeneralInfo = {
-  audioCount: number;
-  videoCount: number;
-  textCount: number;
-  fileSize: number;
-  codec: string;
-  title: string;
-  duration: number;
-  extra?: {
-    duration: string;
-  };
-};
-export type AudioTrackInfo = {
-  is_default: boolean;
-  order: number;
-  codec: string;
-  bitrate: number;
-  framerate: number;
-  sample_rate: number;
-  channels: number;
-  duration: number;
-  lossless: boolean;
-};
-
-export type VideoTrackInfo = {
-  is_default: boolean;
-  order: number;
-  width: number;
-  height: number;
-  codec: string;
-  profile: string;
-  framerate: number;
-  bitrate: number;
-  duration: number;
-  bitdepth: number;
-  format_profile: string;
-  format_tier: string;
-};
-
-export type TextTrackInfo = {
-  is_default: boolean;
-  codec: string;
-  order: number;
-  duration: number;
-  language?: string;
-  title?: string;
-  is_vtt?: boolean;
-};
-
-export type Mediainfo = {
-  general?: GeneralInfo;
-  audio?: AudioTrackInfo[];
-  video?: VideoTrackInfo[];
-  text?: TextTrackInfo[];
+export {
+  parseMediaInfo,
+  parseMediaRaw
 };

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@soga/mediainfo",
-  "version": "0.4.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.5.0",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "rimraf dist && tsup src/index.ts --format cjs,esm --dts",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
   },
+  "files": [
+    "dist"
+  ],
   "keywords": [],
   "author": "",
   "license": "ISC",
@@ -18,6 +24,8 @@
     "tsup": "^8.5.0"
   },
   "devDependencies": {
-    "@types/fs-extra": "^11.0.4"
-  }
+    "@types/fs-extra": "^11.0.4",
+    "rimraf": "^6.0.1"
+  },
+  "prepublishOnly": "npm run build"
 }

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "@repo/typescript-config/node.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}