@rezwanul7/storage 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,464 @@
+// src/shared/fileSize.ts
+var SIZE_UNITS = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 ** 2,
+  gb: 1024 ** 3,
+  tb: 1024 ** 4
+};
+function parseFileSize(input) {
+  if (input == null) return void 0;
+  if (typeof input === "number" && Number.isFinite(input)) return input;
+  if (typeof input !== "string") return void 0;
+  const match = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb)?$/);
+  if (!match) return void 0;
+  return parseFloat(match[1]) * (SIZE_UNITS[match[2] || "b"] ?? 1);
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const index = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, index)).toFixed(1)} ${units[index]}`;
+}
+
+// src/shared/mimeTypes.ts
+var DANGEROUS_EXTENSIONS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "exe",
+  "dll",
+  "com",
+  "scr",
+  "bat",
+  "cmd",
+  "ps1",
+  "jar",
+  "class"
+]);
+var DANGEROUS_MIME = /* @__PURE__ */ new Set([
+  "application/x-sh",
+  "application/x-shellscript",
+  "text/x-shellscript",
+  "text/x-sh",
+  "application/x-dosexec",
+  "application/java-archive"
+]);
+var MIME_BY_EXT = {
+  // Image
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  webp: "image/webp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  svg: "image/svg+xml",
+  ico: "image/vnd.microsoft.icon",
+  avif: "image/avif",
+  heic: "image/heic",
+  // Audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/x-flac",
+  m4a: "audio/mp4",
+  // Video
+  mp4: "video/mp4",
+  mkv: "video/x-matroska",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  webm: "video/webm",
+  // Documents
+  pdf: "application/pdf",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  odt: "application/vnd.oasis.opendocument.text",
+  rtf: "application/rtf",
+  // Datasets (JSON Lines has no registered MIME, so it is served as JSON)
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  json: "application/json",
+  jsonl: "application/json",
+  ndjson: "application/json",
+  // Archives
+  zip: "application/zip",
+  rar: "application/x-rar-compressed",
+  "7z": "application/x-7z-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  // Code
+  js: "text/javascript",
+  jsx: "text/jsx",
+  ts: "text/typescript",
+  tsx: "text/tsx",
+  py: "text/x-python",
+  rb: "text/x-ruby",
+  php: "application/x-httpd-php",
+  java: "text/x-java-source",
+  kt: "text/x-kotlin",
+  c: "text/x-c",
+  cpp: "text/x-c",
+  h: "text/x-c",
+  hpp: "text/x-c",
+  cs: "text/x-csharp",
+  go: "text/x-go",
+  rs: "text/x-rust",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  scss: "text/x-scss",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  sql: "application/sql",
+  xml: "application/xml",
+  // Text
+  txt: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  log: "text/plain",
+  ini: "text/plain",
+  cfg: "text/plain",
+  conf: "text/plain",
+  env: "text/plain",
+  // Executables (blocked by DANGEROUS_EXTENSIONS, mapped so they report a real MIME)
+  sh: "application/x-sh",
+  bash: "application/x-sh",
+  zsh: "application/x-sh",
+  exe: "application/x-msdos-program",
+  dll: "application/x-msdownload",
+  com: "application/x-msdownload",
+  bat: "application/x-msdownload",
+  jar: "application/java-archive",
+  class: "application/java-vm"
+};
+var EXT_BY_MIME = {};
+for (const [ext, mime] of Object.entries(MIME_BY_EXT)) {
+  EXT_BY_MIME[mime] ??= ext;
+}
+function mimeFromExtension(ext) {
+  if (!ext) return void 0;
+  return MIME_BY_EXT[ext.toLowerCase()];
+}
+function extensionFromMime(mime) {
+  if (!mime) return void 0;
+  return EXT_BY_MIME[mime.toLowerCase()];
+}
+
+// src/shared/fileExtension.ts
+function getFileExtension(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot === -1) return void 0;
+  return name.slice(dot + 1).toLowerCase() || void 0;
+}
+
+// src/shared/detectFileTypeFromName.ts
+function detectFileTypeFromName(input) {
+  const name = input.name;
+  const declaredMime = input.type || void 0;
+  const declaredExt = getFileExtension(name);
+  const finalExt = declaredExt;
+  const finalMime = resolveMime(declaredExt, declaredMime);
+  if (declaredExt && DANGEROUS_EXTENSIONS.has(declaredExt)) {
+    return {
+      ok: false,
+      reason: `Extension .${declaredExt} is blocked.`,
+      mime: finalMime,
+      ext: finalExt
+    };
+  }
+  if (declaredMime && DANGEROUS_MIME.has(declaredMime)) {
+    return {
+      ok: false,
+      reason: `MIME type ${declaredMime} is unsafe.`,
+      mime: finalMime,
+      ext: finalExt
+    };
+  }
+  if (declaredExt) {
+    return {
+      ok: true,
+      mime: finalMime,
+      ext: declaredExt
+    };
+  }
+  if (declaredMime) {
+    return {
+      ok: true,
+      mime: declaredMime,
+      ext: extensionFromMime(declaredMime)
+    };
+  }
+  return {
+    ok: false,
+    reason: "Unable to determine file type.",
+    mime: finalMime,
+    ext: void 0
+  };
+}
+function resolveMime(ext, declaredMime) {
+  const lookup = mimeFromExtension(ext);
+  if (lookup) {
+    return lookup;
+  }
+  if (declaredMime) {
+    return declaredMime;
+  }
+  return "application/octet-stream";
+}
+
+// src/shared/fileCategories/fileCategories.detect.ts
+var FILE_CATEGORY_DETECTORS = [
+  // ---- IMAGE ---------------------------------------------------------------
+  {
+    id: "Image",
+    parent: "Image",
+    detect: {
+      mimeStartsWith: ["image/"],
+      extensions: ["png", "jpg", "jpeg", "gif", "bmp", "webp", "tiff", "svg"]
+    }
+  },
+  // ---- AUDIO ---------------------------------------------------------------
+  {
+    id: "Audio",
+    parent: "Audio",
+    detect: {
+      mimeStartsWith: ["audio/"],
+      extensions: ["mp3", "wav", "ogg", "flac", "m4a"]
+    }
+  },
+  // ---- VIDEO ---------------------------------------------------------------
+  {
+    id: "Video",
+    parent: "Video",
+    detect: {
+      mimeStartsWith: ["video/"],
+      extensions: ["mp4", "mkv", "mov", "avi", "webm"]
+    }
+  },
+  // ---- PDF -----------------------------------------------------------------
+  {
+    id: "Pdf",
+    parent: "Document",
+    detect: {
+      mimeEquals: ["application/pdf"],
+      extensions: ["pdf"]
+    }
+  },
+  // ---- SPREADSHEET ---------------------------------------------------------
+  {
+    id: "Spreadsheet",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.oasis.opendocument.spreadsheet"
+      ],
+      extensions: ["xls", "xlsx", "ods"]
+    }
+  },
+  // ---- PRESENTATION --------------------------------------------------------
+  {
+    id: "Presentation",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/vnd.oasis.opendocument.presentation"
+      ],
+      extensions: ["ppt", "pptx", "odp"]
+    }
+  },
+  // ---- DOCUMENT (WORD / RICH DOCS) ----------------------------------------
+  {
+    id: "Document",
+    parent: "Document",
+    detect: {
+      mimeEquals: [
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.oasis.opendocument.text"
+      ],
+      extensions: ["doc", "docx", "odt", "rtf"]
+    }
+  },
+  // ---- DATASET (CSV, JSONL, NDJSON, TSV) -----------------------------------
+  {
+    id: "Dataset",
+    parent: "Document",
+    detect: {
+      mimeEquals: ["text/csv", "application/json", "text/tab-separated-values"],
+      extensions: ["csv", "tsv", "jsonl", "ndjson"]
+    }
+  },
+  // ---- ARCHIVE -------------------------------------------------------------
+  {
+    id: "Archive",
+    parent: "Binary",
+    detect: {
+      mimeEquals: [
+        "application/zip",
+        "application/x-7z-compressed",
+        "application/x-rar-compressed",
+        "application/x-tar",
+        "application/gzip"
+      ],
+      extensions: ["zip", "rar", "7z", "tar", "gz"]
+    }
+  },
+  // ---- CODE ----------------------------------------------------------------
+  {
+    id: "Code",
+    parent: "Text",
+    detect: {
+      // Exact MIMEs (from MIME_BY_EXT) so source files match Code before Text's "text/" prefix
+      mimeEquals: [
+        "text/javascript",
+        "text/jsx",
+        "text/typescript",
+        "text/tsx",
+        "text/x-python",
+        "text/x-ruby",
+        "text/x-java-source",
+        "text/x-kotlin",
+        "text/x-c",
+        "text/x-csharp",
+        "text/x-go",
+        "text/x-rust",
+        "text/html",
+        "text/css",
+        "text/x-scss",
+        "text/yaml"
+      ],
+      extensions: [
+        "js",
+        "ts",
+        "tsx",
+        "jsx",
+        "py",
+        "rb",
+        "php",
+        "java",
+        "kt",
+        "c",
+        "cpp",
+        "h",
+        "hpp",
+        "cs",
+        "go",
+        "rs",
+        "sh",
+        "bash",
+        "zsh",
+        "html",
+        "css",
+        "scss",
+        "json",
+        "yml",
+        "yaml",
+        "sql"
+      ]
+    }
+  },
+  // ---- TEXT (PLAIN, MARKDOWN, LOGS, ETC.) ----------------------------------
+  {
+    id: "Text",
+    parent: "Text",
+    detect: {
+      mimeStartsWith: ["text/"],
+      extensions: ["txt", "md", "markdown", "log", "ini", "cfg", "conf", "env"]
+    }
+  },
+  // ---- BINARY (FALLBACK FOR NON-TEXT, NON-ARCHIVE) -------------------------
+  {
+    id: "Binary",
+    parent: "Binary",
+    detect: {
+      mimeEquals: ["application/octet-stream"]
+    }
+  },
+  // ---- UNKNOWN -------------------------------------------------------------
+  {
+    id: "Unknown",
+    parent: "Unknown"
+  }
+];
+
+// src/shared/fileCategories/getFileCategory.ts
+function getFileCategory(input) {
+  const mime = normalize(input.mime);
+  const ext = normalize(input.ext);
+  if (mime) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const eq = def.detect?.mimeEquals;
+      if (eq && eq.includes(mime)) {
+        return def.id;
+      }
+    }
+  }
+  if (mime) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const prefixes = def.detect?.mimeStartsWith;
+      if (prefixes && prefixes.some((p) => mime.startsWith(p))) {
+        return def.id;
+      }
+    }
+  }
+  if (ext) {
+    for (const def of FILE_CATEGORY_DETECTORS) {
+      const exts = def.detect?.extensions;
+      if (exts && exts.includes(ext)) {
+        return def.id;
+      }
+    }
+  }
+  return "Unknown";
+}
+function normalize(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim().toLowerCase();
+  return trimmed || void 0;
+}
+
+// src/shared/fileCategories/getExtensionsByCategory.ts
+function getExtensionsByCategory(category) {
+  const extensions = FILE_CATEGORY_DETECTORS.find((c) => c.id === category)?.detect?.extensions;
+  if (!extensions?.length) {
+    throw new Error(
+      `File category '${category}' does not define extensions. Please add the configuration in fileCategories.detect.ts.`
+    );
+  }
+  return [...extensions];
+}
+function getExtensionsByCategories(categories) {
+  return Array.from(
+    new Set(
+      categories.flatMap((category) => getExtensionsByCategory(category))
+    )
+  );
+}
+
+// src/shared/fileCategories/getMimeTypesByCategory.ts
+function getMimeTypesByCategory(category) {
+  const mimeEquals = FILE_CATEGORY_DETECTORS.find((c) => c.id === category)?.detect?.mimeEquals;
+  if (!mimeEquals?.length) {
+    throw new Error(
+      `File category '${category}' does not define 'mimeEquals'. Please add the configuration in fileCategories.detect.ts.`
+    );
+  }
+  return [...mimeEquals];
+}
+function getMimeTypesByCategories(categories) {
+  return Array.from(new Set(categories.flatMap(getMimeTypesByCategory)));
+}
+
+export { FILE_CATEGORY_DETECTORS, detectFileTypeFromName, formatFileSize, getExtensionsByCategories, getExtensionsByCategory, getFileCategory, getFileExtension, getMimeTypesByCategories, getMimeTypesByCategory, parseFileSize };