@hanzo/s3 0.6.4 → 8.0.7

package/dist/esm/helpers.mjs

@@ -0,0 +1,218 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as querystring from 'query-string';
+import * as errors from "./errors.mjs";
+import { getEncryptionHeaders, isEmpty, isEmptyObject, isNumber, isObject, isString, isValidBucketName, isValidObjectName } from "./internal/helper.mjs";
+import { RETENTION_MODES } from "./internal/type.mjs";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.mjs";
+export const DEFAULT_REGION = 'us-east-1';
+export const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7; // 7 days in seconds
+
+export class CopySourceOptions {
+  constructor({
+    Bucket,
+    Object,
+    VersionID = '',
+    MatchETag = '',
+    NoMatchETag = '',
+    MatchModifiedSince = null,
+    MatchUnmodifiedSince = null,
+    MatchRange = false,
+    Start = 0,
+    End = 0,
+    Encryption = undefined
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.VersionID = VersionID;
+    this.MatchETag = MatchETag;
+    this.NoMatchETag = NoMatchETag;
+    this.MatchModifiedSince = MatchModifiedSince;
+    this.MatchUnmodifiedSince = MatchUnmodifiedSince;
+    this.MatchRange = MatchRange;
+    this.Start = Start;
+    this.End = End;
+    this.Encryption = Encryption;
+  }
+  validate() {
+    if (!isValidBucketName(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket);
+    }
+    if (!isValidObjectName(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Source object name: ${this.Object}`);
+    }
+    if (this.MatchRange && this.Start !== -1 && this.End !== -1 && this.Start > this.End || this.Start < 0) {
+      throw new errors.InvalidObjectNameError('Source start must be non-negative, and start must be at most end.');
+    } else if (this.MatchRange && !isNumber(this.Start) || !isNumber(this.End)) {
+      throw new errors.InvalidObjectNameError('MatchRange is specified. But Invalid Start and End values are specified.');
+    }
+    return true;
+  }
+  getHeaders() {
+    const headerOptions = {};
+    headerOptions['x-amz-copy-source'] = encodeURI(this.Bucket + '/' + this.Object);
+    if (!isEmpty(this.VersionID)) {
+      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`;
+    }
+    if (!isEmpty(this.MatchETag)) {
+      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag;
+    }
+    if (!isEmpty(this.NoMatchETag)) {
+      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag;
+    }
+    if (!isEmpty(this.MatchModifiedSince)) {
+      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince;
+    }
+    if (!isEmpty(this.MatchUnmodifiedSince)) {
+      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince;
+    }
+    return headerOptions;
+  }
+}
+
+/**
+ * @deprecated use nodejs fs module
+ */
+export function removeDirAndFiles(dirPath, removeSelf = true) {
+  if (removeSelf) {
+    return fs.rmSync(dirPath, {
+      recursive: true,
+      force: true
+    });
+  }
+  fs.readdirSync(dirPath).forEach(item => {
+    fs.rmSync(path.join(dirPath, item), {
+      recursive: true,
+      force: true
+    });
+  });
+}
+export class CopyDestinationOptions {
+  constructor({
+    Bucket,
+    Object,
+    Encryption,
+    UserMetadata,
+    UserTags,
+    LegalHold,
+    RetainUntilDate,
+    Mode,
+    MetadataDirective,
+    Headers
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.Encryption = Encryption ?? undefined; // null input will become undefined, easy for runtime assert
+    this.UserMetadata = UserMetadata;
+    this.UserTags = UserTags;
+    this.LegalHold = LegalHold;
+    this.Mode = Mode; // retention mode
+    this.RetainUntilDate = RetainUntilDate;
+    this.MetadataDirective = MetadataDirective;
+    this.Headers = Headers;
+  }
+  getHeaders() {
+    const replaceDirective = 'REPLACE';
+    const headerOptions = {};
+    const userTags = this.UserTags;
+    if (!isEmpty(userTags)) {
+      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective;
+      headerOptions['X-Amz-Tagging'] = isObject(userTags) ? querystring.stringify(userTags) : isString(userTags) ? userTags : '';
+    }
+    if (this.Mode) {
+      headerOptions['X-Amz-Object-Lock-Mode'] = this.Mode; // GOVERNANCE or COMPLIANCE
+    }
+
+    if (this.RetainUntilDate) {
+      headerOptions['X-Amz-Object-Lock-Retain-Until-Date'] = this.RetainUntilDate; // needs to be UTC.
+    }
+
+    if (this.LegalHold) {
+      headerOptions['X-Amz-Object-Lock-Legal-Hold'] = this.LegalHold; // ON or OFF
+    }
+
+    if (this.UserMetadata) {
+      for (const [key, value] of Object.entries(this.UserMetadata)) {
+        headerOptions[`X-Amz-Meta-${key}`] = value.toString();
+      }
+    }
+    if (this.MetadataDirective) {
+      headerOptions[`X-Amz-Metadata-Directive`] = this.MetadataDirective;
+    }
+    if (this.Encryption) {
+      const encryptionHeaders = getEncryptionHeaders(this.Encryption);
+      for (const [key, value] of Object.entries(encryptionHeaders)) {
+        headerOptions[key] = value;
+      }
+    }
+    if (this.Headers) {
+      for (const [key, value] of Object.entries(this.Headers)) {
+        headerOptions[key] = value;
+      }
+    }
+    return headerOptions;
+  }
+  validate() {
+    if (!isValidBucketName(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket);
+    }
+    if (!isValidObjectName(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`);
+    }
+    if (!isEmpty(this.UserMetadata) && !isObject(this.UserMetadata)) {
+      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`);
+    }
+    if (!isEmpty(this.Mode) && ![RETENTION_MODES.GOVERNANCE, RETENTION_MODES.COMPLIANCE].includes(this.Mode)) {
+      throw new errors.InvalidObjectNameError(`Invalid Mode specified for destination object it should be one of [GOVERNANCE,COMPLIANCE]`);
+    }
+    if (this.Encryption !== undefined && isEmptyObject(this.Encryption)) {
+      throw new errors.InvalidObjectNameError(`Invalid Encryption configuration for destination object `);
+    }
+    return true;
+  }
+}
+
+/**
+ * maybe this should be a generic type for Records, leave it for later refactor
+ */
+export class SelectResults {
+  constructor({
+    records,
+    // parsed data as stream
+    response,
+    // original response stream
+    stats,
+    // stats as xml
+    progress // stats as xml
+  }) {
+    this.records = records;
+    this.response = response;
+    this.stats = stats;
+    this.progress = progress;
+  }
+  setStats(stats) {
+    this.stats = stats;
+  }
+  getStats() {
+    return this.stats;
+  }
+  setProgress(progress) {
+    this.progress = progress;
+  }
+  getProgress() {
+    return this.progress;
+  }
+  setResponse(response) {
+    this.response = response;
+  }
+  getResponse() {
+    return this.response;
+  }
+  setRecords(records) {
+    this.records = records;
+  }
+  getRecords() {
+    return this.records;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","path","querystring","errors","getEncryptionHeaders","isEmpty","isEmptyObject","isNumber","isObject","isString","isValidBucketName","isValidObjectName","RETENTION_MODES","ENCRYPTION_TYPES","LEGAL_HOLD_STATUS","RETENTION_VALIDITY_UNITS","DEFAULT_REGION","PRESIGN_EXPIRY_DAYS_MAX","CopySourceOptions","constructor","Bucket","Object","VersionID","MatchETag","NoMatchETag","MatchModifiedSince","MatchUnmodifiedSince","MatchRange","Start","End","Encryption","undefined","validate","InvalidBucketNameError","InvalidObjectNameError","getHeaders","headerOptions","encodeURI","removeDirAndFiles","dirPath","removeSelf","rmSync","recursive","force","readdirSync","forEach","item","join","CopyDestinationOptions","UserMetadata","UserTags","LegalHold","RetainUntilDate","Mode","MetadataDirective","Headers","replaceDirective","userTags","stringify","key","value","entries","toString","encryptionHeaders","GOVERNANCE","COMPLIANCE","includes","SelectResults","records","response","stats","progress","setStats","getStats","setProgress","getProgress","setResponse","getResponse","setRecords","getRecords"],"sources":["helpers.ts"],"sourcesContent":["import * as fs from 'node:fs'\nimport * as path from 'node:path'\n\nimport * as querystring from 'query-string'\n\nimport * as errors from './errors.ts'\nimport {\n  getEncryptionHeaders,\n  isEmpty,\n  isEmptyObject,\n  isNumber,\n  isObject,\n  isString,\n  isValidBucketName,\n  isValidObjectName,\n} from './internal/helper.ts'\nimport type { Encryption, ObjectMetaData, RequestHeaders } from './internal/type.ts'\nimport { RETENTION_MODES } from './internal/type.ts'\n\nexport { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\nexport const DEFAULT_REGION = 'us-east-1'\n\nexport const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7 // 7 days in seconds\n\nexport interface ICopySourceOptions {\n  Bucket: string\n  Object: string\n  /**\n   * Valid versionId\n   */\n  VersionID?: string\n  /**\n   * Etag to match\n   */\n  MatchETag?: string\n  /**\n   * Etag to exclude\n   */\n  NoMatchETag?: string\n  /**\n   * Modified Date of the object/part.  UTC Date in string format\n   */\n  MatchModifiedSince?: string | null\n  /**\n   * Modified Date of the object/part to exclude UTC Date in string format\n   */\n  MatchUnmodifiedSince?: string | null\n  /**\n   * true or false Object range to match\n   */\n  MatchRange?: boolean\n  Start?: number\n  End?: number\n  Encryption?: Encryption\n}\n\nexport class CopySourceOptions {\n  public readonly Bucket: string\n  public readonly Object: string\n  public readonly VersionID: string\n  public MatchETag: string\n  private readonly NoMatchETag: string\n  private readonly MatchModifiedSince: string | null\n  private readonly MatchUnmodifiedSince: string | null\n  public readonly MatchRange: boolean\n  public readonly Start: number\n  public readonly End: number\n  private readonly Encryption?: Encryption\n\n  constructor({\n    Bucket,\n    Object,\n    VersionID = '',\n    MatchETag = '',\n    NoMatchETag = '',\n    MatchModifiedSince = null,\n    MatchUnmodifiedSince = null,\n    MatchRange = false,\n    Start = 0,\n    End = 0,\n    Encryption = undefined,\n  }: ICopySourceOptions) {\n    this.Bucket = Bucket\n    this.Object = Object\n    this.VersionID = VersionID\n    this.MatchETag = MatchETag\n    this.NoMatchETag = NoMatchETag\n    this.MatchModifiedSince = MatchModifiedSince\n    this.MatchUnmodifiedSince = MatchUnmodifiedSince\n    this.MatchRange = MatchRange\n    this.Start = Start\n    this.End = End\n    this.Encryption = Encryption\n  }\n\n  validate() {\n    if (!isValidBucketName(this.Bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket)\n    }\n    if (!isValidObjectName(this.Object)) {\n      throw new errors.InvalidObjectNameError(`Invalid Source object name: ${this.Object}`)\n    }\n    if ((this.MatchRange && this.Start !== -1 && this.End !== -1 && this.Start > this.End) || this.Start < 0) {\n      throw new errors.InvalidObjectNameError('Source start must be non-negative, and start must be at most end.')\n    } else if ((this.MatchRange && !isNumber(this.Start)) || !isNumber(this.End)) {\n      throw new errors.InvalidObjectNameError(\n        'MatchRange is specified. But Invalid Start and End values are specified.',\n      )\n    }\n\n    return true\n  }\n\n  getHeaders(): RequestHeaders {\n    const headerOptions: RequestHeaders = {}\n    headerOptions['x-amz-copy-source'] = encodeURI(this.Bucket + '/' + this.Object)\n\n    if (!isEmpty(this.VersionID)) {\n      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`\n    }\n\n    if (!isEmpty(this.MatchETag)) {\n      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag\n    }\n    if (!isEmpty(this.NoMatchETag)) {\n      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag\n    }\n\n    if (!isEmpty(this.MatchModifiedSince)) {\n      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince\n    }\n    if (!isEmpty(this.MatchUnmodifiedSince)) {\n      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince\n    }\n\n    return headerOptions\n  }\n}\n\n/**\n * @deprecated use nodejs fs module\n */\nexport function removeDirAndFiles(dirPath: string, removeSelf = true) {\n  if (removeSelf) {\n    return fs.rmSync(dirPath, { recursive: true, force: true })\n  }\n\n  fs.readdirSync(dirPath).forEach((item) => {\n    fs.rmSync(path.join(dirPath, item), { recursive: true, force: true })\n  })\n}\n\nexport interface ICopyDestinationOptions {\n  /**\n   * Bucket name\n   */\n  Bucket: string\n  /**\n   * Object Name for the destination (composed/copied) object defaults\n   */\n  Object: string\n  /**\n   * Encryption configuration defaults to {}\n   * @default {}\n   */\n  Encryption?: Encryption\n  UserMetadata?: ObjectMetaData\n  /**\n   * query-string encoded string or Record<string, string> Object\n   */\n  UserTags?: Record<string, string> | string\n  LegalHold?: 'on' | 'off'\n  /**\n   * UTC Date String\n   */\n  RetainUntilDate?: string\n  Mode?: RETENTION_MODES\n  MetadataDirective?: 'COPY' | 'REPLACE'\n  /**\n   * Extra headers for the target object\n   */\n  Headers?: Record<string, string>\n}\n\nexport class CopyDestinationOptions {\n  public readonly Bucket: string\n  public readonly Object: string\n  private readonly Encryption?: Encryption\n  private readonly UserMetadata?: ObjectMetaData\n  private readonly UserTags?: Record<string, string> | string\n  private readonly LegalHold?: 'on' | 'off'\n  private readonly RetainUntilDate?: string\n  private readonly Mode?: RETENTION_MODES\n  private readonly MetadataDirective?: string\n  private readonly Headers?: Record<string, string>\n\n  constructor({\n    Bucket,\n    Object,\n    Encryption,\n    UserMetadata,\n    UserTags,\n    LegalHold,\n    RetainUntilDate,\n    Mode,\n    MetadataDirective,\n    Headers,\n  }: ICopyDestinationOptions) {\n    this.Bucket = Bucket\n    this.Object = Object\n    this.Encryption = Encryption ?? undefined // null input will become undefined, easy for runtime assert\n    this.UserMetadata = UserMetadata\n    this.UserTags = UserTags\n    this.LegalHold = LegalHold\n    this.Mode = Mode // retention mode\n    this.RetainUntilDate = RetainUntilDate\n    this.MetadataDirective = MetadataDirective\n    this.Headers = Headers\n  }\n\n  getHeaders(): RequestHeaders {\n    const replaceDirective = 'REPLACE'\n    const headerOptions: RequestHeaders = {}\n\n    const userTags = this.UserTags\n    if (!isEmpty(userTags)) {\n      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective\n      headerOptions['X-Amz-Tagging'] = isObject(userTags)\n        ? querystring.stringify(userTags)\n        : isString(userTags)\n        ? userTags\n        : ''\n    }\n\n    if (this.Mode) {\n      headerOptions['X-Amz-Object-Lock-Mode'] = this.Mode // GOVERNANCE or COMPLIANCE\n    }\n\n    if (this.RetainUntilDate) {\n      headerOptions['X-Amz-Object-Lock-Retain-Until-Date'] = this.RetainUntilDate // needs to be UTC.\n    }\n\n    if (this.LegalHold) {\n      headerOptions['X-Amz-Object-Lock-Legal-Hold'] = this.LegalHold // ON or OFF\n    }\n\n    if (this.UserMetadata) {\n      for (const [key, value] of Object.entries(this.UserMetadata)) {\n        headerOptions[`X-Amz-Meta-${key}`] = value.toString()\n      }\n    }\n\n    if (this.MetadataDirective) {\n      headerOptions[`X-Amz-Metadata-Directive`] = this.MetadataDirective\n    }\n\n    if (this.Encryption) {\n      const encryptionHeaders = getEncryptionHeaders(this.Encryption)\n      for (const [key, value] of Object.entries(encryptionHeaders)) {\n        headerOptions[key] = value\n      }\n    }\n    if (this.Headers) {\n      for (const [key, value] of Object.entries(this.Headers)) {\n        headerOptions[key] = value\n      }\n    }\n\n    return headerOptions\n  }\n\n  validate() {\n    if (!isValidBucketName(this.Bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket)\n    }\n    if (!isValidObjectName(this.Object)) {\n      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`)\n    }\n    if (!isEmpty(this.UserMetadata) && !isObject(this.UserMetadata)) {\n      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`)\n    }\n\n    if (!isEmpty(this.Mode) && ![RETENTION_MODES.GOVERNANCE, RETENTION_MODES.COMPLIANCE].includes(this.Mode)) {\n      throw new errors.InvalidObjectNameError(\n        `Invalid Mode specified for destination object it should be one of [GOVERNANCE,COMPLIANCE]`,\n      )\n    }\n\n    if (this.Encryption !== undefined && isEmptyObject(this.Encryption)) {\n      throw new errors.InvalidObjectNameError(`Invalid Encryption configuration for destination object `)\n    }\n    return true\n  }\n}\n\n/**\n * maybe this should be a generic type for Records, leave it for later refactor\n */\nexport class SelectResults {\n  private records?: unknown\n  private response?: unknown\n  private stats?: string\n  private progress?: unknown\n\n  constructor({\n    records, // parsed data as stream\n    response, // original response stream\n    stats, // stats as xml\n    progress, // stats as xml\n  }: {\n    records?: unknown\n    response?: unknown\n    stats?: string\n    progress?: unknown\n  }) {\n    this.records = records\n    this.response = response\n    this.stats = stats\n    this.progress = progress\n  }\n\n  setStats(stats: string) {\n    this.stats = stats\n  }\n\n  getStats() {\n    return this.stats\n  }\n\n  setProgress(progress: unknown) {\n    this.progress = progress\n  }\n\n  getProgress() {\n    return this.progress\n  }\n\n  setResponse(response: unknown) {\n    this.response = response\n  }\n\n  getResponse() {\n    return this.response\n  }\n\n  setRecords(records: unknown) {\n    this.records = records\n  }\n\n  getRecords(): unknown {\n    return this.records\n  }\n}\n"],"mappings":"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"}

package/dist/esm/internal/async.d.mts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as fs from 'node:fs';
+import * as stream from 'node:stream';
+export { promises as fsp } from 'node:fs';
+export declare const streamPromise: {
+  pipeline: typeof stream.pipeline.__promisify__;
+};
+export declare const fstat: typeof fs.fstat.__promisify__;

package/dist/esm/internal/async.mjs

@@ -0,0 +1,14 @@
+// promise helper for stdlib
+
+import * as fs from "fs";
+import * as stream from "stream";
+import { promisify } from "util";
+
+// TODO: use "node:fs/promise" directly after we stop testing on nodejs 12
+export { promises as fsp } from 'node:fs';
+export const streamPromise = {
+  // node:stream/promises Added in: v15.0.0
+  pipeline: promisify(stream.pipeline)
+};
+export const fstat = promisify(fs.fstat);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsInN0cmVhbSIsInByb21pc2lmeSIsInByb21pc2VzIiwiZnNwIiwic3RyZWFtUHJvbWlzZSIsInBpcGVsaW5lIiwiZnN0YXQiXSwic291cmNlcyI6WyJhc3luYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBwcm9taXNlIGhlbHBlciBmb3Igc3RkbGliXG5cbmltcG9ydCAqIGFzIGZzIGZyb20gJ25vZGU6ZnMnXG5pbXBvcnQgKiBhcyBzdHJlYW0gZnJvbSAnbm9kZTpzdHJlYW0nXG5pbXBvcnQgeyBwcm9taXNpZnkgfSBmcm9tICdub2RlOnV0aWwnXG5cbi8vIFRPRE86IHVzZSBcIm5vZGU6ZnMvcHJvbWlzZVwiIGRpcmVjdGx5IGFmdGVyIHdlIHN0b3AgdGVzdGluZyBvbiBub2RlanMgMTJcbmV4cG9ydCB7IHByb21pc2VzIGFzIGZzcCB9IGZyb20gJ25vZGU6ZnMnXG5leHBvcnQgY29uc3Qgc3RyZWFtUHJvbWlzZSA9IHtcbiAgLy8gbm9kZTpzdHJlYW0vcHJvbWlzZXMgQWRkZWQgaW46IHYxNS4wLjBcbiAgcGlwZWxpbmU6IHByb21pc2lmeShzdHJlYW0ucGlwZWxpbmUpLFxufVxuXG5leHBvcnQgY29uc3QgZnN0YXQgPSBwcm9taXNpZnkoZnMuZnN0YXQpXG4iXSwibWFwcGluZ3MiOiJBQUFBOztBQUVBLE9BQU8sS0FBS0EsRUFBRTtBQUNkLE9BQU8sS0FBS0MsTUFBTTtBQUNsQixTQUFTQyxTQUFTOztBQUVsQjtBQUNBLFNBQVNDLFFBQVEsSUFBSUMsR0FBRyxRQUFRLFNBQVM7QUFDekMsT0FBTyxNQUFNQyxhQUFhLEdBQUc7RUFDM0I7RUFDQUMsUUFBUSxFQUFFSixTQUFTLENBQUNELE1BQU0sQ0FBQ0ssUUFBUTtBQUNyQyxDQUFDO0FBRUQsT0FBTyxNQUFNQyxLQUFLLEdBQUdMLFNBQVMsQ0FBQ0YsRUFBRSxDQUFDTyxLQUFLLENBQUMifQ==

package/dist/esm/internal/callbackify.d.mts

@@ -0,0 +1 @@
+export declare function callbackify(fn: (...args: any[]) => any): (this: any, ...args: any[]) => any;

package/dist/esm/internal/callbackify.mjs

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Wrapper for an async function that supports callback style API.
+// It will preserve 'this'.
+export function callbackify(fn) {
+  return function (...args) {
+    const lastArg = args[args.length - 1];
+    if (typeof lastArg === 'function') {
+      const callback = args.pop();
+      return fn.apply(this, args).then(result => callback(null, result), err => callback(err));
+    }
+    return fn.apply(this, args);
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImxhc3RBcmciLCJsZW5ndGgiLCJjYWxsYmFjayIsInBvcCIsImFwcGx5IiwidGhlbiIsInJlc3VsdCIsImVyciJdLCJzb3VyY2VzIjpbImNhbGxiYWNraWZ5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnkgKi9cblxuLy8gV3JhcHBlciBmb3IgYW4gYXN5bmMgZnVuY3Rpb24gdGhhdCBzdXBwb3J0cyBjYWxsYmFjayBzdHlsZSBBUEkuXG4vLyBJdCB3aWxsIHByZXNlcnZlICd0aGlzJy5cbmV4cG9ydCBmdW5jdGlvbiBjYWxsYmFja2lmeShmbjogKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICh0aGlzOiBhbnksIC4uLmFyZ3M6IGFueVtdKSB7XG4gICAgY29uc3QgbGFzdEFyZyA9IGFyZ3NbYXJncy5sZW5ndGggLSAxXVxuXG4gICAgaWYgKHR5cGVvZiBsYXN0QXJnID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcbiAgICAgIHJldHVybiBmbi5hcHBseSh0aGlzLCBhcmdzKS50aGVuKFxuICAgICAgICAocmVzdWx0OiBhbnkpID0+IGNhbGxiYWNrKG51bGwsIHJlc3VsdCksXG4gICAgICAgIChlcnI6IGFueSkgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncylcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQTs7QUFFQTtBQUNBO0FBQ0EsT0FBTyxTQUFTQSxXQUFXQSxDQUFDQyxFQUEyQixFQUFFO0VBQ3ZELE9BQU8sVUFBcUIsR0FBR0MsSUFBVyxFQUFFO0lBQzFDLE1BQU1DLE9BQU8sR0FBR0QsSUFBSSxDQUFDQSxJQUFJLENBQUNFLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFFckMsSUFBSSxPQUFPRCxPQUFPLEtBQUssVUFBVSxFQUFFO01BQ2pDLE1BQU1FLFFBQVEsR0FBR0gsSUFBSSxDQUFDSSxHQUFHLENBQUMsQ0FBQztNQUMzQixPQUFPTCxFQUFFLENBQUNNLEtBQUssQ0FBQyxJQUFJLEVBQUVMLElBQUksQ0FBQyxDQUFDTSxJQUFJLENBQzdCQyxNQUFXLElBQUtKLFFBQVEsQ0FBQyxJQUFJLEVBQUVJLE1BQU0sQ0FBQyxFQUN0Q0MsR0FBUSxJQUFLTCxRQUFRLENBQUNLLEdBQUcsQ0FDNUIsQ0FBQztJQUNIO0lBRUEsT0FBT1QsRUFBRSxDQUFDTSxLQUFLLENBQUMsSUFBSSxFQUFFTCxJQUFJLENBQUM7RUFDN0IsQ0FBQztBQUNIIn0=