@quicktvui/ai 1.0.6 → 1.0.7

package/rules/.source/ESAxios/index.js

@@ -0,0 +1,43 @@
+import axios from "./lib/axios.js";
+
+// This module is intended to unwrap Axios default export as named.
+// Keep top-level export same with static properties
+// so that it can keep same with es module or cjs
+const {
+  Axios,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken,
+  VERSION,
+  all,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig,
+} = axios;
+
+export {
+  axios as default,
+  Axios,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken,
+  VERSION,
+  all,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig,
+};

package/rules/.source/ESAxios/lib/adapters/README.md

@@ -0,0 +1,37 @@
+# axios // adapters
+
+The modules under `adapters/` are modules that handle dispatching a request and settling a returned `Promise` once a response is received.
+
+## Example
+
+```js
+var settle = require('./../core/settle');
+
+module.exports = function myAdapter(config) {
+  // At this point:
+  //  - config has been merged with defaults
+  //  - request transformers have already run
+  //  - request interceptors have already run
+  
+  // Make the request using config provided
+  // Upon response settle the Promise
+
+  return new Promise(function(resolve, reject) {
+  
+    var response = {
+      data: responseData,
+      status: request.status,
+      statusText: request.statusText,
+      headers: responseHeaders,
+      config: config,
+      request: request
+    };
+
+    settle(resolve, reject, response);
+
+    // From here:
+    //  - response transformers will run
+    //  - response interceptors will run
+  });
+}
+```

package/rules/.source/ESAxios/lib/adapters/adapters.js

@@ -0,0 +1,80 @@
+import utils from "../utils.js";
+import fetchAdapter from "./fetch.js";
+import AxiosError from "../core/AxiosError.js";
+
+const knownAdapters = {
+  fetch: fetchAdapter,
+};
+
+utils.forEach(knownAdapters, (fn, value) => {
+  if (fn) {
+    try {
+      Object.defineProperty(fn, "name", { value });
+    } catch (e) {
+      // eslint-disable-next-line no-empty
+    }
+    Object.defineProperty(fn, "adapterName", { value });
+  }
+});
+
+const renderReason = (reason) => `- ${reason}`;
+
+const isResolvedHandle = (adapter) =>
+  utils.isFunction(adapter) || adapter === null || adapter === false;
+
+export default {
+  getAdapter: (adapters) => {
+    adapters = utils.isArray(adapters) ? adapters : [adapters];
+
+    const { length } = adapters;
+    let nameOrAdapter;
+    let adapter;
+
+    const rejectedReasons = {};
+
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters[i];
+      let id;
+
+      adapter = nameOrAdapter;
+
+      if (!isResolvedHandle(nameOrAdapter)) {
+        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+
+        if (adapter === undefined) {
+          throw new AxiosError(`Unknown adapter '${id}'`);
+        }
+      }
+
+      if (adapter) {
+        break;
+      }
+
+      rejectedReasons[id || "#" + i] = adapter;
+    }
+
+    if (!adapter) {
+      const reasons = Object.entries(rejectedReasons).map(
+        ([id, state]) =>
+          `adapter ${id} ` +
+          (state === false
+            ? "is not supported by the environment"
+            : "is not available in the build"),
+      );
+
+      let s = length
+        ? reasons.length > 1
+          ? "since :\n" + reasons.map(renderReason).join("\n")
+          : " " + renderReason(reasons[0])
+        : "as no adapter specified";
+
+      throw new AxiosError(
+        `There is no suitable adapter to dispatch the request ` + s,
+        "ERR_NOT_SUPPORT",
+      );
+    }
+
+    return adapter;
+  },
+  adapters: knownAdapters,
+};

package/rules/.source/ESAxios/lib/adapters/fetch.js

@@ -0,0 +1,295 @@
+import platform from "../platform/index.js";
+import utils from "../utils.js";
+import AxiosError from "../core/AxiosError.js";
+import composeSignals from "../helpers/composeSignals.js";
+import { trackStream } from "../helpers/trackStream.js";
+import AxiosHeaders from "../core/AxiosHeaders.js";
+import {
+  progressEventReducer,
+  progressEventDecorator,
+  asyncDecorator,
+} from "../helpers/progressEventReducer.js";
+import resolveConfig from "../helpers/resolveConfig.js";
+import settle from "../core/settle.js";
+
+const isFetchSupported =
+  typeof fetch === "function" &&
+  typeof Request === "function" &&
+  typeof Response === "function";
+const isReadableStreamSupported =
+  isFetchSupported && typeof ReadableStream === "function";
+
+// used only inside the fetch adapter
+const encodeText =
+  isFetchSupported &&
+  (typeof TextEncoder === "function"
+    ? (
+        (encoder) => (str) =>
+          encoder.encode(str)
+      )(new TextEncoder())
+    : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
+
+const test = (fn, ...args) => {
+  try {
+    return !!fn(...args);
+  } catch (e) {
+    return false;
+  }
+};
+
+const supportsRequestStream =
+  isReadableStreamSupported &&
+  test(() => {
+    let duplexAccessed = false;
+
+    const hasContentType = new Request(platform.origin, {
+      body: new ReadableStream(),
+      method: "POST",
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      },
+    }).headers.has("Content-Type");
+
+    return duplexAccessed && !hasContentType;
+  });
+
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+const supportsResponseStream =
+  isReadableStreamSupported &&
+  test(() => utils.isReadableStream(new Response("").body));
+
+const resolvers = {
+  stream: supportsResponseStream && ((res) => res.body),
+};
+
+((res) => {
+  ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
+    !resolvers[type] &&
+      (resolvers[type] = utils.isFunction(res[type])
+        ? (res) => res[type]()
+        : (_, config) => {
+            throw new AxiosError(
+              `Response type '${type}' is not supported`,
+              AxiosError.ERR_NOT_SUPPORT,
+              config,
+            );
+          });
+  });
+})(new Response());
+
+const getBodyLength = async (body) => {
+  if (body == null) {
+    return 0;
+  }
+
+  if (utils.isBlob(body)) {
+    return body.size;
+  }
+
+  if (utils.isSpecCompliantForm(body)) {
+    const _request = new Request(platform.origin, {
+      method: "POST",
+      body,
+    });
+    return (await _request.arrayBuffer()).byteLength;
+  }
+
+  if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
+    return body.byteLength;
+  }
+
+  if (utils.isURLSearchParams(body)) {
+    body = body + "";
+  }
+
+  if (utils.isString(body)) {
+    return (await encodeText(body)).byteLength;
+  }
+};
+
+const resolveBodyLength = async (headers, body) => {
+  const length = utils.toFiniteNumber(headers.getContentLength());
+
+  return length == null ? getBodyLength(body) : length;
+};
+
+export default async (config) => {
+  let {
+    url,
+    method,
+    data,
+    signal,
+    cancelToken,
+    timeout,
+    onDownloadProgress,
+    onUploadProgress,
+    responseType,
+    headers,
+    withCredentials = "same-origin",
+    fetchOptions,
+  } = resolveConfig(config);
+
+  responseType = responseType ? (responseType + "").toLowerCase() : "text";
+
+  let composedSignal = composeSignals(
+    [signal, cancelToken && cancelToken.toAbortSignal()],
+    timeout,
+  );
+
+  let request;
+
+  const unsubscribe =
+    composedSignal &&
+    composedSignal.unsubscribe &&
+    (() => {
+      composedSignal.unsubscribe();
+    });
+
+  let requestContentLength;
+
+  try {
+    if (
+      onUploadProgress &&
+      supportsRequestStream &&
+      method !== "get" &&
+      method !== "head" &&
+      (requestContentLength = await resolveBodyLength(headers, data)) !== 0
+    ) {
+      let _request = new Request(url, {
+        method: "POST",
+        body: data,
+        duplex: "half",
+      });
+
+      let contentTypeHeader;
+
+      if (
+        utils.isFormData(data) &&
+        (contentTypeHeader = _request.headers.get("content-type"))
+      ) {
+        headers.setContentType(contentTypeHeader);
+      }
+
+      if (_request.body) {
+        const [onProgress, flush] = progressEventDecorator(
+          requestContentLength,
+          progressEventReducer(asyncDecorator(onUploadProgress)),
+        );
+
+        data = trackStream(
+          _request.body,
+          DEFAULT_CHUNK_SIZE,
+          onProgress,
+          flush,
+        );
+      }
+    }
+
+    if (!utils.isString(withCredentials)) {
+      withCredentials = withCredentials ? "include" : "omit";
+    }
+
+    // Cloudflare Workers throws when credentials are defined
+    // see https://github.com/cloudflare/workerd/issues/902
+    const isCredentialsSupported = false; //"credentials" in Request.prototype;
+
+    const requestHeaders = new Headers();
+
+    for (let key in headers) {
+      if (headers.hasOwnProperty(key)) {
+        requestHeaders.append(key, headers[key]);
+      }
+    }
+
+    let requestOptions = {
+      ...fetchOptions,
+      signal: composedSignal,
+      method: method.toUpperCase(),
+      headers: requestHeaders,
+      body: data,
+      duplex: "half",
+      credentials: isCredentialsSupported ? withCredentials : undefined,
+    };
+
+    request = {
+      url,
+      requestOptions,
+    };
+
+    let response = await fetch(url, requestOptions);
+
+    const isStreamResponse =
+      supportsResponseStream &&
+      (responseType === "stream" || responseType === "response");
+
+    if (
+      supportsResponseStream &&
+      (onDownloadProgress || (isStreamResponse && unsubscribe))
+    ) {
+      const options = {};
+
+      ["status", "statusText", "headers"].forEach((prop) => {
+        options[prop] = response[prop];
+      });
+
+      const responseContentLength = utils.toFiniteNumber(
+        response.headers.get("content-length"),
+      );
+
+      const [onProgress, flush] =
+        (onDownloadProgress &&
+          progressEventDecorator(
+            responseContentLength,
+            progressEventReducer(asyncDecorator(onDownloadProgress), true),
+          )) ||
+        [];
+
+      response = new Response(
+        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+          flush && flush();
+          unsubscribe && unsubscribe();
+        }),
+        options,
+      );
+    }
+
+    responseType = responseType || "text";
+
+    let responseData = await resolvers[
+      utils.findKey(resolvers, responseType) || "text"
+    ](response, config);
+
+    !isStreamResponse && unsubscribe && unsubscribe();
+
+    return await new Promise((resolve, reject) => {
+      settle(resolve, reject, {
+        data: responseData,
+        headers: AxiosHeaders.from(response.headers),
+        status: response.status,
+        statusText: response.statusText,
+        config,
+        request,
+      });
+    });
+  } catch (err) {
+    unsubscribe && unsubscribe();
+
+    if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
+      throw Object.assign(
+        new AxiosError(
+          "Network Error",
+          AxiosError.ERR_NETWORK,
+          config,
+          request,
+        ),
+        {
+          cause: err.cause || err,
+        },
+      );
+    }
+
+    throw AxiosError.from(err, err && err.code, config, request);
+  }
+};

package/rules/.source/ESAxios/lib/axios.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import utils from "./utils.js";
+import bind from "./helpers/bind.js";
+import Axios from "./core/Axios.js";
+import mergeConfig from "./core/mergeConfig.js";
+import defaults from "./defaults/index.js";
+import formDataToJSON from "./helpers/formDataToJSON.js";
+import CanceledError from "./cancel/CanceledError.js";
+import CancelToken from "./cancel/CancelToken.js";
+import isCancel from "./cancel/isCancel.js";
+import { VERSION } from "./env/data.js";
+import toFormData from "./helpers/toFormData.js";
+import AxiosError from "./core/AxiosError.js";
+import spread from "./helpers/spread.js";
+import isAxiosError from "./helpers/isAxiosError.js";
+import AxiosHeaders from "./core/AxiosHeaders.js";
+import adapters from "./adapters/adapters.js";
+import HttpStatusCode from "./helpers/HttpStatusCode.js";
+
+/**
+ * Create an instance of Axios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ *
+ * @returns {Axios} A new instance of Axios
+ */
+function createInstance(defaultConfig) {
+  const context = new Axios(defaultConfig);
+  const instance = bind(Axios.prototype.request, context);
+
+  // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context, { allOwnKeys: true });
+
+  // Copy context to instance
+  utils.extend(instance, context, null, { allOwnKeys: true });
+
+  // Factory for creating new instances
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+
+  return instance;
+}
+
+// Create the default instance to be exported
+const axios = createInstance(defaults);
+
+// Expose Axios class to allow class inheritance
+axios.Axios = Axios;
+
+// Expose Cancel & CancelToken
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
+
+// Expose AxiosError class
+axios.AxiosError = AxiosError;
+
+// alias for CanceledError for backward compatibility
+axios.Cancel = axios.CanceledError;
+
+// Expose all/spread
+axios.all = function all(promises) {
+  return Promise.all(promises);
+};
+
+axios.spread = spread;
+
+// Expose isAxiosError
+axios.isAxiosError = isAxiosError;
+
+// Expose mergeConfig
+axios.mergeConfig = mergeConfig;
+
+axios.AxiosHeaders = AxiosHeaders;
+
+axios.formToJSON = (thing) =>
+  formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
+
+axios.getAdapter = adapters.getAdapter;
+
+axios.HttpStatusCode = HttpStatusCode;
+
+axios.default = axios;
+
+// this module should only have a default export
+export default axios;

package/rules/.source/ESAxios/lib/cancel/CancelToken.js

@@ -0,0 +1,135 @@
+"use strict";
+
+import CanceledError from "./CanceledError.js";
+
+/**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @param {Function} executor The executor function.
+ *
+ * @returns {CancelToken}
+ */
+class CancelToken {
+  constructor(executor) {
+    if (typeof executor !== "function") {
+      throw new TypeError("executor must be a function.");
+    }
+
+    let resolvePromise;
+
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+
+    const token = this;
+
+    // eslint-disable-next-line func-names
+    this.promise.then((cancel) => {
+      if (!token._listeners) return;
+
+      let i = token._listeners.length;
+
+      while (i-- > 0) {
+        token._listeners[i](cancel);
+      }
+      token._listeners = null;
+    });
+
+    // eslint-disable-next-line func-names
+    this.promise.then = (onfulfilled) => {
+      let _resolve;
+      // eslint-disable-next-line func-names
+      const promise = new Promise((resolve) => {
+        token.subscribe(resolve);
+        _resolve = resolve;
+      }).then(onfulfilled);
+
+      promise.cancel = function reject() {
+        token.unsubscribe(_resolve);
+      };
+
+      return promise;
+    };
+
+    executor(function cancel(message, config, request) {
+      if (token.reason) {
+        // Cancellation has already been requested
+        return;
+      }
+
+      token.reason = new CanceledError(message, config, request);
+      resolvePromise(token.reason);
+    });
+  }
+
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  }
+
+  /**
+   * Subscribe to the cancel signal
+   */
+
+  subscribe(listener) {
+    if (this.reason) {
+      listener(this.reason);
+      return;
+    }
+
+    if (this._listeners) {
+      this._listeners.push(listener);
+    } else {
+      this._listeners = [listener];
+    }
+  }
+
+  /**
+   * Unsubscribe from the cancel signal
+   */
+
+  unsubscribe(listener) {
+    if (!this._listeners) {
+      return;
+    }
+    const index = this._listeners.indexOf(listener);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
+    }
+  }
+
+  toAbortSignal() {
+    const controller = new AbortController();
+
+    const abort = (err) => {
+      controller.abort(err);
+    };
+
+    this.subscribe(abort);
+
+    controller.signal.unsubscribe = () => this.unsubscribe(abort);
+
+    return controller.signal;
+  }
+
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let cancel;
+    const token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token,
+      cancel,
+    };
+  }
+}
+
+export default CancelToken;

package/rules/.source/ESAxios/lib/cancel/CanceledError.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import AxiosError from "../core/AxiosError.js";
+import utils from "../utils.js";
+
+/**
+ * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @param {string=} message The message.
+ * @param {Object=} config The config.
+ * @param {Object=} request The request.
+ *
+ * @returns {CanceledError} The created error.
+ */
+function CanceledError(message, config, request) {
+  // eslint-disable-next-line no-eq-null,eqeqeq
+  AxiosError.call(
+    this,
+    message == null ? "canceled" : message,
+    AxiosError.ERR_CANCELED,
+    config,
+    request,
+  );
+  this.name = "CanceledError";
+}
+
+utils.inherits(CanceledError, AxiosError, {
+  __CANCEL__: true,
+});
+
+export default CanceledError;