s3mini 0.1.1 → 0.3.0

package/src/utils.ts

@@ -17,6 +17,10 @@ export const hash = (content: string | Buffer): string => {
   return _createHash('sha256').update(content).digest('hex') as string;
 };
 
+export const md5base64 = (data: string | Buffer): string => {
+  return _createHash('md5').update(data).digest('base64') as string;
+};
+
 /**
  * Compute HMAC-SHA-256 of arbitrary data and return a hex string.
  * @param {string|Buffer} key      – secret key
@@ -53,6 +57,20 @@ const entityMap = {
   '&': '&',
 } as const;
 
+/**
+ * Escape special characters for XML
+ * @param value String to escape
+ * @returns XML-escaped string
+ */
+export const escapeXml = (value: string): string => {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+};
+
 const unescapeXml = (value: string): string =>
   value.replace(/&(quot|apos|lt|gt|amp);/g, m => entityMap[m as keyof typeof entityMap] ?? m);
 
@@ -62,31 +80,35 @@ const unescapeXml = (value: string): string =>
  * @param input raw XML string
  * @returns string for leaf nodes, otherwise a map of children
  */
+
 export const parseXml = (input: string): XmlValue => {
-  const RE_TAG = /<(\w)([-\w]+)(?:\/|[^>]*>((?:(?!<\1)[\s\S])*)<\/\1\2)>/gm;
+  const xmlContent = input.replace(/<\?xml[^?]*\?>\s*/, '');
+  const RE_TAG = /<([A-Za-z_][\w\-.]*)[^>]*>([\s\S]*?)<\/\1>/gm;
   const result: XmlMap = {}; // strong type, no `any`
   let match: RegExpExecArray | null;
 
-  while ((match = RE_TAG.exec(input)) !== null) {
-    const [, prefix = '', key, inner] = match;
-    const fullKey = `${prefix.toLowerCase()}${key}`;
-    const node: XmlValue = inner ? parseXml(inner) : '';
-
-    const current = result[fullKey];
+  while ((match = RE_TAG.exec(xmlContent)) !== null) {
+    const tagName = match[1];
+    const innerContent = match[2];
+    const node: XmlValue = innerContent ? parseXml(innerContent) : unescapeXml(innerContent?.trim() || '');
+    if (!tagName) {
+      continue;
+    }
+    const current = result[tagName];
     if (current === undefined) {
-      // first occurrence
-      result[fullKey] = node;
+      // First occurrence
+      result[tagName] = node;
     } else if (Array.isArray(current)) {
-      // already an array
+      // Already an array
       current.push(node);
     } else {
-      // promote to array on the second occurrence
-      result[fullKey] = [current, node];
+      // Promote to array on the second occurrence
+      result[tagName] = [current, node];
     }
   }
 
   // No child tags? — return the text, after entity decode
-  return Object.keys(result).length > 0 ? result : unescapeXml(input);
+  return Object.keys(result).length > 0 ? result : unescapeXml(xmlContent.trim());
 };
 
 /**
@@ -159,15 +181,15 @@ export class S3ServiceError extends S3Error {
  * @param {Iterable<() => Promise<unknonw>>} tasks       – functions returning Promises
  * @param {number} [batchSize=30]                    – max concurrent requests
  * @param {number} [minIntervalMs=0]                 – ≥0; 0 means “no pacing”
- * @returns {Promise<Array<PromiseSettledResult<unknonw>>>}
+ * @returns {Promise<Array<PromiseSettledResult<T>>>}
  */
-export const runInBatches = async (
-  tasks: Iterable<() => Promise<unknown>>,
+export const runInBatches = async <T = unknown>(
+  tasks: Iterable<() => Promise<T>>,
   batchSize: number = 30,
   minIntervalMs: number = 0,
-): Promise<Array<PromiseSettledResult<unknown>>> => {
-  const allResults: PromiseSettledResult<unknown>[] = [];
-  let batch: Array<() => Promise<unknown>> = [];
+): Promise<Array<PromiseSettledResult<T>>> => {
+  const allResults: PromiseSettledResult<T>[] = [];
+  let batch: Array<() => Promise<T>> = [];
 
   for (const task of tasks) {
     batch.push(task);
@@ -182,16 +204,18 @@ export const runInBatches = async (
   return allResults;
 
   // ───────── helpers ──────────
-  async function executeBatch(batchFns: Array<() => Promise<unknown>>): Promise<void> {
-    const start = Date.now();
+  async function executeBatch(batchFns: ReadonlyArray<() => Promise<T>>): Promise<void> {
+    const start: number = Date.now();
 
-    const settled = await Promise.allSettled(batchFns.map(fn => fn()));
+    const settled: Array<PromiseSettledResult<T>> = await Promise.allSettled(
+      batchFns.map((fn: () => Promise<T>) => fn()),
+    );
     allResults.push(...settled);
 
     if (minIntervalMs > 0) {
-      const wait = minIntervalMs - (Date.now() - start);
+      const wait: number = minIntervalMs - (Date.now() - start);
       if (wait > 0) {
-        await new Promise(r => setTimeout(r, wait));
+        await new Promise<void>((resolve: () => void) => setTimeout(resolve, wait));
       }
     }
   }