@snagsolutions/sdk 0.1.0-alpha.230 → 0.1.0-alpha.232

package/src/error.ts

@@ -1,2 +1,130 @@
-/** @deprecated Import from ./core/error instead */
-export * from './core/error';
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError, Headers } from './core';
+
+export class SnagSolutionsError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends SnagSolutionsError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+
+  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/index.ts

@@ -1,10 +1,345 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { SnagSolutions as default } from './client';
+import { type Agent } from './_shims/index';
+import * as qs from './internal/qs';
+import * as Core from './core';
+import * as Errors from './error';
+import * as Uploads from './uploads';
+import * as API from './resources/index';
+import { AssetCreateAssetParams, AssetCreateAssetResponse, Assets } from './resources/assets';
+import {
+  Auth,
+  AuthConnectAuthParams,
+  AuthConnectAuthResponse,
+  AuthConnectAuthVerifyParams,
+  AuthConnectAuthVerifyResponse,
+} from './resources/auth';
+import {
+  TokenClaimCheckEligibilityParams,
+  TokenClaimCheckEligibilityResponse,
+  TokenClaimGetProofParams,
+  TokenClaimGetProofResponse,
+  TokenClaimListParams,
+  TokenClaimListResponse,
+  TokenClaimListUsersParams,
+  TokenClaimListUsersResponse,
+  TokenClaimRetrieveParams,
+  TokenClaimRetrieveResponse,
+  TokenClaimUpdateClaimParams,
+  TokenClaimUpdateClaimResponse,
+  TokenClaims,
+} from './resources/token-claims';
+import {
+  AuctionGetPageSectionsParams,
+  AuctionGetPageSectionsResponse,
+  AuctionListAuctionBidsParams,
+  AuctionListAuctionBidsResponse,
+  AuctionListAuctionsResponse,
+  Auctions,
+} from './resources/auctions/auctions';
+import { Loyalty } from './resources/loyalty/loyalty';
+import {
+  Minting,
+  MintingGetAssetsParams,
+  MintingGetAssetsResponse,
+  MintingGetTokenGateStatusParams,
+  MintingGetTokenGateStatusResponse,
+} from './resources/minting/minting';
+import {
+  Referral,
+  ReferralCreateCodeParams,
+  ReferralCreateCodeResponse,
+} from './resources/referral/referral';
+import {
+  UserConnectParams,
+  UserConnectResponse,
+  UserCountParams,
+  UserCountResponse,
+  UserCreateDeviceParams,
+  UserCreateDeviceResponse,
+  UserDisconnectParams,
+  UserDisconnectResponse,
+  UserListParams,
+  UserListResponse,
+  UserVerifyParams,
+  UserVerifyResponse,
+  Users,
+} from './resources/users/users';
+import {
+  WebsiteCreateParams,
+  WebsiteCreateResponse,
+  WebsiteListParams,
+  WebsiteListResponse,
+  Websites,
+} from './resources/websites/websites';
 
-export { type Uploadable, toFile } from './core/uploads';
-export { APIPromise } from './core/api-promise';
-export { SnagSolutions, type ClientOptions } from './client';
+export interface ClientOptions {
+  /**
+   * API key required to authenticate with the Snag Solutions API.
+   */
+  apiKey?: string | undefined;
+
+  /**
+   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+   *
+   * Defaults to process.env['SNAG_SOLUTIONS_BASE_URL'].
+   */
+  baseURL?: string | null | undefined;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+   * much longer than this timeout before the promise succeeds or fails.
+   *
+   * @unit milliseconds
+   */
+  timeout?: number | undefined;
+
+  /**
+   * An HTTP agent used to manage HTTP(S) connections.
+   *
+   * If not provided, an agent will be constructed by default in the Node.js environment,
+   * otherwise no agent is used.
+   */
+  httpAgent?: Agent | undefined;
+
+  /**
+   * Specify a custom `fetch` function implementation.
+   *
+   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
+   * defined globally.
+   */
+  fetch?: Core.Fetch | undefined;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
+  maxRetries?: number | undefined;
+
+  /**
+   * Default headers to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * header to `undefined` or `null` in request options.
+   */
+  defaultHeaders?: Core.Headers | undefined;
+
+  /**
+   * Default query parameters to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * param to `undefined` in request options.
+   */
+  defaultQuery?: Core.DefaultQuery | undefined;
+}
+
+/**
+ * API Client for interfacing with the Snag Solutions API.
+ */
+export class SnagSolutions extends Core.APIClient {
+  apiKey: string;
+
+  private _options: ClientOptions;
+
+  /**
+   * API Client for interfacing with the Snag Solutions API.
+   *
+   * @param {string | undefined} [opts.apiKey=process.env['X_API_KEY'] ?? undefined]
+   * @param {string} [opts.baseURL=process.env['SNAG_SOLUTIONS_BASE_URL'] ?? https://admin.snagsolutions.io/] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   */
+  constructor({
+    baseURL = Core.readEnv('SNAG_SOLUTIONS_BASE_URL'),
+    apiKey = Core.readEnv('X_API_KEY'),
+    ...opts
+  }: ClientOptions = {}) {
+    if (apiKey === undefined) {
+      throw new Errors.SnagSolutionsError(
+        "The X_API_KEY environment variable is missing or empty; either provide it, or instantiate the SnagSolutions client with an apiKey option, like new SnagSolutions({ apiKey: 'My API Key' }).",
+      );
+    }
+
+    const options: ClientOptions = {
+      apiKey,
+      ...opts,
+      baseURL: baseURL || `https://admin.snagsolutions.io/`,
+    };
+
+    super({
+      baseURL: options.baseURL!,
+      baseURLOverridden: baseURL ? baseURL !== 'https://admin.snagsolutions.io/' : false,
+      timeout: options.timeout ?? 60000 /* 1 minute */,
+      httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
+      fetch: options.fetch,
+    });
+
+    this._options = options;
+
+    this.apiKey = apiKey;
+  }
+
+  assets: API.Assets = new API.Assets(this);
+  auth: API.Auth = new API.Auth(this);
+  auctions: API.Auctions = new API.Auctions(this);
+  users: API.Users = new API.Users(this);
+  loyalty: API.Loyalty = new API.Loyalty(this);
+  minting: API.Minting = new API.Minting(this);
+  referral: API.Referral = new API.Referral(this);
+  websites: API.Websites = new API.Websites(this);
+  tokenClaims: API.TokenClaims = new API.TokenClaims(this);
+
+  /**
+   * Check whether the base URL is set to its default.
+   */
+  #baseURLOverridden(): boolean {
+    return this.baseURL !== 'https://admin.snagsolutions.io/';
+  }
+
+  protected override defaultQuery(): Core.DefaultQuery | undefined {
+    return this._options.defaultQuery;
+  }
+
+  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return {
+      ...super.defaultHeaders(opts),
+      ...this._options.defaultHeaders,
+    };
+  }
+
+  protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return { 'X-API-KEY': this.apiKey };
+  }
+
+  protected override stringifyQuery(query: Record<string, unknown>): string {
+    return qs.stringify(query, { arrayFormat: 'repeat' });
+  }
+
+  static SnagSolutions = this;
+  static DEFAULT_TIMEOUT = 60000; // 1 minute
+
+  static SnagSolutionsError = Errors.SnagSolutionsError;
+  static APIError = Errors.APIError;
+  static APIConnectionError = Errors.APIConnectionError;
+  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+  static APIUserAbortError = Errors.APIUserAbortError;
+  static NotFoundError = Errors.NotFoundError;
+  static ConflictError = Errors.ConflictError;
+  static RateLimitError = Errors.RateLimitError;
+  static BadRequestError = Errors.BadRequestError;
+  static AuthenticationError = Errors.AuthenticationError;
+  static InternalServerError = Errors.InternalServerError;
+  static PermissionDeniedError = Errors.PermissionDeniedError;
+  static UnprocessableEntityError = Errors.UnprocessableEntityError;
+
+  static toFile = Uploads.toFile;
+  static fileFromPath = Uploads.fileFromPath;
+}
+
+SnagSolutions.Assets = Assets;
+SnagSolutions.Auth = Auth;
+SnagSolutions.Auctions = Auctions;
+SnagSolutions.Users = Users;
+SnagSolutions.Loyalty = Loyalty;
+SnagSolutions.Minting = Minting;
+SnagSolutions.Referral = Referral;
+SnagSolutions.Websites = Websites;
+SnagSolutions.TokenClaims = TokenClaims;
+
+export declare namespace SnagSolutions {
+  export type RequestOptions = Core.RequestOptions;
+
+  export {
+    Assets as Assets,
+    type AssetCreateAssetResponse as AssetCreateAssetResponse,
+    type AssetCreateAssetParams as AssetCreateAssetParams,
+  };
+
+  export {
+    Auth as Auth,
+    type AuthConnectAuthResponse as AuthConnectAuthResponse,
+    type AuthConnectAuthVerifyResponse as AuthConnectAuthVerifyResponse,
+    type AuthConnectAuthParams as AuthConnectAuthParams,
+    type AuthConnectAuthVerifyParams as AuthConnectAuthVerifyParams,
+  };
+
+  export {
+    Auctions as Auctions,
+    type AuctionGetPageSectionsResponse as AuctionGetPageSectionsResponse,
+    type AuctionListAuctionBidsResponse as AuctionListAuctionBidsResponse,
+    type AuctionListAuctionsResponse as AuctionListAuctionsResponse,
+    type AuctionGetPageSectionsParams as AuctionGetPageSectionsParams,
+    type AuctionListAuctionBidsParams as AuctionListAuctionBidsParams,
+  };
+
+  export {
+    Users as Users,
+    type UserListResponse as UserListResponse,
+    type UserConnectResponse as UserConnectResponse,
+    type UserCountResponse as UserCountResponse,
+    type UserCreateDeviceResponse as UserCreateDeviceResponse,
+    type UserDisconnectResponse as UserDisconnectResponse,
+    type UserVerifyResponse as UserVerifyResponse,
+    type UserListParams as UserListParams,
+    type UserConnectParams as UserConnectParams,
+    type UserCountParams as UserCountParams,
+    type UserCreateDeviceParams as UserCreateDeviceParams,
+    type UserDisconnectParams as UserDisconnectParams,
+    type UserVerifyParams as UserVerifyParams,
+  };
+
+  export { Loyalty as Loyalty };
+
+  export {
+    Minting as Minting,
+    type MintingGetAssetsResponse as MintingGetAssetsResponse,
+    type MintingGetTokenGateStatusResponse as MintingGetTokenGateStatusResponse,
+    type MintingGetAssetsParams as MintingGetAssetsParams,
+    type MintingGetTokenGateStatusParams as MintingGetTokenGateStatusParams,
+  };
+
+  export {
+    Referral as Referral,
+    type ReferralCreateCodeResponse as ReferralCreateCodeResponse,
+    type ReferralCreateCodeParams as ReferralCreateCodeParams,
+  };
+
+  export {
+    Websites as Websites,
+    type WebsiteCreateResponse as WebsiteCreateResponse,
+    type WebsiteListResponse as WebsiteListResponse,
+    type WebsiteCreateParams as WebsiteCreateParams,
+    type WebsiteListParams as WebsiteListParams,
+  };
+
+  export {
+    TokenClaims as TokenClaims,
+    type TokenClaimRetrieveResponse as TokenClaimRetrieveResponse,
+    type TokenClaimListResponse as TokenClaimListResponse,
+    type TokenClaimCheckEligibilityResponse as TokenClaimCheckEligibilityResponse,
+    type TokenClaimGetProofResponse as TokenClaimGetProofResponse,
+    type TokenClaimListUsersResponse as TokenClaimListUsersResponse,
+    type TokenClaimUpdateClaimResponse as TokenClaimUpdateClaimResponse,
+    type TokenClaimRetrieveParams as TokenClaimRetrieveParams,
+    type TokenClaimListParams as TokenClaimListParams,
+    type TokenClaimCheckEligibilityParams as TokenClaimCheckEligibilityParams,
+    type TokenClaimGetProofParams as TokenClaimGetProofParams,
+    type TokenClaimListUsersParams as TokenClaimListUsersParams,
+    type TokenClaimUpdateClaimParams as TokenClaimUpdateClaimParams,
+  };
+}
+
+export { toFile, fileFromPath } from './uploads';
 export {
   SnagSolutionsError,
   APIError,
@@ -19,4 +354,6 @@ export {
   InternalServerError,
   PermissionDeniedError,
   UnprocessableEntityError,
-} from './core/error';
+} from './error';
+
+export default SnagSolutions;

package/src/internal/qs/formats.ts

@@ -1,10 +1,9 @@
 import type { Format } from './types';
 
 export const default_format: Format = 'RFC3986';
-export const default_formatter = (v: PropertyKey) => String(v);
 export const formatters: Record<Format, (str: PropertyKey) => string> = {
   RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
-  RFC3986: default_formatter,
+  RFC3986: (v: PropertyKey) => String(v),
 };
 export const RFC1738 = 'RFC1738';
 export const RFC3986 = 'RFC3986';

package/src/internal/qs/stringify.ts

@@ -1,7 +1,8 @@
-import { encode, is_buffer, maybe_map, has } from './utils';
-import { default_format, default_formatter, formatters } from './formats';
+import { encode, is_buffer, maybe_map } from './utils';
+import { default_format, formatters } from './formats';
 import type { NonNullableProperties, StringifyOptions } from './types';
-import { isArray } from '../utils/values';
+
+const has = Object.prototype.hasOwnProperty;
 
 const array_prefix_generators = {
   brackets(prefix: PropertyKey) {
@@ -16,11 +17,13 @@ const array_prefix_generators = {
   },
 };
 
+const is_array = Array.isArray;
+const push = Array.prototype.push;
 const push_to_array = function (arr: any[], value_or_array: any) {
-  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
+  push.apply(arr, is_array(value_or_array) ? value_or_array : [value_or_array]);
 };
 
-let toISOString;
+const to_ISO = Date.prototype.toISOString;
 
 const defaults = {
   addQueryPrefix: false,
@@ -35,11 +38,11 @@ const defaults = {
   encoder: encode,
   encodeValuesOnly: false,
   format: default_format,
-  formatter: default_formatter,
+  formatter: formatters[default_format],
   /** @deprecated */
   indices: false,
   serializeDate(date) {
-    return (toISOString ??= Function.prototype.call.bind(Date.prototype.toISOString))(date);
+    return to_ISO.call(date);
   },
   skipNulls: false,
   strictNullHandling: false,
@@ -102,7 +105,7 @@ function inner_stringify(
     obj = filter(prefix, obj);
   } else if (obj instanceof Date) {
     obj = serializeDate?.(obj);
-  } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
+  } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
     obj = maybe_map(obj, function (value) {
       if (value instanceof Date) {
         return serializeDate?.(value);
@@ -145,14 +148,14 @@ function inner_stringify(
   }
 
   let obj_keys;
-  if (generateArrayPrefix === 'comma' && isArray(obj)) {
+  if (generateArrayPrefix === 'comma' && is_array(obj)) {
     // we need to join elements in
     if (encodeValuesOnly && encoder) {
       // @ts-expect-error values only
       obj = maybe_map(obj, encoder);
     }
     obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
-  } else if (isArray(filter)) {
+  } else if (is_array(filter)) {
     obj_keys = filter;
   } else {
     const keys = Object.keys(obj);
@@ -162,9 +165,9 @@ function inner_stringify(
   const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
 
   const adjusted_prefix =
-    commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+    commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
 
-  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+  if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
     return adjusted_prefix + '[]';
   }
 
@@ -181,7 +184,7 @@ function inner_stringify(
     // @ts-ignore
     const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
     const key_prefix =
-      isArray(obj) ?
+      is_array(obj) ?
         typeof generateArrayPrefix === 'function' ?
           generateArrayPrefix(adjusted_prefix, encoded_key)
         : adjusted_prefix
@@ -202,7 +205,7 @@ function inner_stringify(
         skipNulls,
         encodeDotInKeys,
         // @ts-ignore
-        generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
+        generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
         filter,
         sort,
         allowDots,
@@ -241,7 +244,7 @@ function normalize_stringify_options(
 
   let format = default_format;
   if (typeof opts.format !== 'undefined') {
-    if (!has(formatters, opts.format)) {
+    if (!has.call(formatters, opts.format)) {
       throw new TypeError('Unknown format option provided.');
     }
     format = opts.format;
@@ -249,7 +252,7 @@ function normalize_stringify_options(
   const formatter = formatters[format];
 
   let filter = defaults.filter;
-  if (typeof opts.filter === 'function' || isArray(opts.filter)) {
+  if (typeof opts.filter === 'function' || is_array(opts.filter)) {
     filter = opts.filter;
   }
 
@@ -313,7 +316,7 @@ export function stringify(object: any, opts: StringifyOptions = {}) {
   if (typeof options.filter === 'function') {
     filter = options.filter;
     obj = filter('', obj);
-  } else if (isArray(options.filter)) {
+  } else if (is_array(options.filter)) {
     filter = options.filter;
     obj_keys = filter;
   }

package/src/internal/qs/utils.ts

@@ -1,13 +1,10 @@
 import { RFC1738 } from './formats';
 import type { DefaultEncoder, Format } from './types';
-import { isArray } from '../utils/values';
 
-export let has = (obj: object, key: PropertyKey): boolean => (
-  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
-  has(obj, key)
-);
+const has = Object.prototype.hasOwnProperty;
+const is_array = Array.isArray;
 
-const hex_table = /* @__PURE__ */ (() => {
+const hex_table = (() => {
   const array = [];
   for (let i = 0; i < 256; ++i) {
     array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
@@ -23,7 +20,7 @@ function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; pro
 
     const obj = item.obj[item.prop];
 
-    if (isArray(obj)) {
+    if (is_array(obj)) {
       const compacted: unknown[] = [];
 
       for (let j = 0; j < obj.length; ++j) {
@@ -59,10 +56,13 @@ export function merge(
   }
 
   if (typeof source !== 'object') {
-    if (isArray(target)) {
+    if (is_array(target)) {
       target.push(source);
     } else if (target && typeof target === 'object') {
-      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+      if (
+        (options && (options.plainObjects || options.allowPrototypes)) ||
+        !has.call(Object.prototype, source)
+      ) {
         target[source] = true;
       }
     } else {
@@ -77,14 +77,14 @@ export function merge(
   }
 
   let mergeTarget = target;
-  if (isArray(target) && !isArray(source)) {
+  if (is_array(target) && !is_array(source)) {
     // @ts-ignore
     mergeTarget = array_to_object(target, options);
   }
 
-  if (isArray(target) && isArray(source)) {
+  if (is_array(target) && is_array(source)) {
     source.forEach(function (item, i) {
-      if (has(target, i)) {
+      if (has.call(target, i)) {
         const targetItem = target[i];
         if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
           target[i] = merge(targetItem, item, options);
@@ -101,7 +101,7 @@ export function merge(
   return Object.keys(source).reduce(function (acc, key) {
     const value = source[key];
 
-    if (has(acc, key)) {
+    if (has.call(acc, key)) {
       acc[key] = merge(acc[key], value, options);
     } else {
       acc[key] = value;
@@ -254,7 +254,7 @@ export function combine(a: any, b: any) {
 }
 
 export function maybe_map<T>(val: T[], fn: (v: T) => T) {
-  if (isArray(val)) {
+  if (is_array(val)) {
     const mapped = [];
     for (let i = 0; i < val.length; i += 1) {
       mapped.push(fn(val[i]!));