skill-tree 0.1.7 → 0.2.1

package/dist/chunk-QZ7TP4HQ.mjs

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};

package/dist/chunk-RJYJGJO3.mjs

@@ -0,0 +1,349 @@
+import {
+  buildAbortError,
+  getTransformedHeaders,
+  timing,
+  writeRequestBody
+} from "./chunk-3BCRI4CA.mjs";
+import {
+  HttpResponse,
+  buildQueryString
+} from "./chunk-YDVZIFIU.mjs";
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// node_modules/@smithy/node-http-handler/dist-es/constants.js
+var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+
+// node_modules/@smithy/node-http-handler/dist-es/node-https.js
+import node_https from "https";
+
+// node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+var DEFER_EVENT_LISTENER_TIME = 1e3;
+var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
+  if (!timeoutInMs) {
+    return -1;
+  }
+  const registerTimeout = (offset) => {
+    const timeoutId = timing.setTimeout(() => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
+        name: "TimeoutError"
+      }));
+    }, timeoutInMs - offset);
+    const doWithSocket = (socket) => {
+      if (socket?.connecting) {
+        socket.on("connect", () => {
+          timing.clearTimeout(timeoutId);
+        });
+      } else {
+        timing.clearTimeout(timeoutId);
+      }
+    };
+    if (request.socket) {
+      doWithSocket(request.socket);
+    } else {
+      request.on("socket", doWithSocket);
+    }
+  };
+  if (timeoutInMs < 2e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-request-timeout.js
+var setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
+  if (timeoutInMs) {
+    return timing.setTimeout(() => {
+      let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
+      if (throwOnRequestTimeout) {
+        const error = Object.assign(new Error(msg), {
+          name: "TimeoutError",
+          code: "ETIMEDOUT"
+        });
+        req.destroy(error);
+        reject(error);
+      } else {
+        msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
+        logger?.warn?.(msg);
+      }
+    }, timeoutInMs);
+  }
+  return -1;
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
+var DEFER_EVENT_LISTENER_TIME2 = 3e3;
+var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
+  if (keepAlive !== true) {
+    return -1;
+  }
+  const registerListener = () => {
+    if (request.socket) {
+      request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+    } else {
+      request.on("socket", (socket) => {
+        socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+      });
+    }
+  };
+  if (deferTimeMs === 0) {
+    registerListener();
+    return 0;
+  }
+  return timing.setTimeout(registerListener, deferTimeMs);
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
+var DEFER_EVENT_LISTENER_TIME3 = 3e3;
+var setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+  const registerTimeout = (offset) => {
+    const timeout = timeoutInMs - offset;
+    const onTimeout = () => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
+    };
+    if (request.socket) {
+      request.socket.setTimeout(timeout, onTimeout);
+      request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
+    } else {
+      request.setTimeout(timeout, onTimeout);
+    }
+  };
+  if (0 < timeoutInMs && timeoutInMs < 6e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
+};
+
+// node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+var hAgent = void 0;
+var hRequest = void 0;
+var NodeHttpHandler = class _NodeHttpHandler {
+  constructor(options) {
+    __publicField(this, "config");
+    __publicField(this, "configProvider");
+    __publicField(this, "socketWarningTimestamp", 0);
+    __publicField(this, "externalAgent", false);
+    __publicField(this, "metadata", { handlerProtocol: "http/1.1" });
+    this.configProvider = new Promise((resolve, reject) => {
+      if (typeof options === "function") {
+        options().then((_options) => {
+          resolve(this.resolveDefaultConfig(_options));
+        }).catch(reject);
+      } else {
+        resolve(this.resolveDefaultConfig(options));
+      }
+    });
+  }
+  static create(instanceOrOptions) {
+    if (typeof instanceOrOptions?.handle === "function") {
+      return instanceOrOptions;
+    }
+    return new _NodeHttpHandler(instanceOrOptions);
+  }
+  static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
+    const { sockets, requests, maxSockets } = agent;
+    if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+      return socketWarningTimestamp;
+    }
+    const interval = 15e3;
+    if (Date.now() - interval < socketWarningTimestamp) {
+      return socketWarningTimestamp;
+    }
+    if (sockets && requests) {
+      for (const origin in sockets) {
+        const socketsInUse = sockets[origin]?.length ?? 0;
+        const requestsEnqueued = requests[origin]?.length ?? 0;
+        if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
+          logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
+or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
+          return Date.now();
+        }
+      }
+    }
+    return socketWarningTimestamp;
+  }
+  destroy() {
+    this.config?.httpAgent?.destroy();
+    this.config?.httpsAgent?.destroy();
+  }
+  async handle(request, { abortSignal, requestTimeout } = {}) {
+    if (!this.config) {
+      this.config = await this.configProvider;
+    }
+    const config = this.config;
+    const isSSL = request.protocol === "https:";
+    if (!isSSL && !this.config.httpAgent) {
+      this.config.httpAgent = await this.config.httpAgentProvider();
+    }
+    return new Promise((_resolve, _reject) => {
+      let writeRequestBodyPromise = void 0;
+      let socketWarningTimeoutId = -1;
+      let connectionTimeoutId = -1;
+      let requestTimeoutId = -1;
+      let socketTimeoutId = -1;
+      let keepAliveTimeoutId = -1;
+      const clearTimeouts = () => {
+        timing.clearTimeout(socketWarningTimeoutId);
+        timing.clearTimeout(connectionTimeoutId);
+        timing.clearTimeout(requestTimeoutId);
+        timing.clearTimeout(socketTimeoutId);
+        timing.clearTimeout(keepAliveTimeoutId);
+      };
+      const resolve = async (arg) => {
+        await writeRequestBodyPromise;
+        clearTimeouts();
+        _resolve(arg);
+      };
+      const reject = async (arg) => {
+        await writeRequestBodyPromise;
+        clearTimeouts();
+        _reject(arg);
+      };
+      if (abortSignal?.aborted) {
+        const abortError = buildAbortError(abortSignal);
+        reject(abortError);
+        return;
+      }
+      const headers = request.headers;
+      const expectContinue = headers ? (headers.Expect ?? headers.expect) === "100-continue" : false;
+      let agent = isSSL ? config.httpsAgent : config.httpAgent;
+      if (expectContinue && !this.externalAgent) {
+        agent = new (isSSL ? node_https.Agent : hAgent)({
+          keepAlive: false,
+          maxSockets: Infinity
+        });
+      }
+      socketWarningTimeoutId = timing.setTimeout(() => {
+        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
+      }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2e3) + (config.connectionTimeout ?? 1e3));
+      const queryString = request.query ? buildQueryString(request.query) : "";
+      let auth = void 0;
+      if (request.username != null || request.password != null) {
+        const username = request.username ?? "";
+        const password = request.password ?? "";
+        auth = `${username}:${password}`;
+      }
+      let path = request.path;
+      if (queryString) {
+        path += `?${queryString}`;
+      }
+      if (request.fragment) {
+        path += `#${request.fragment}`;
+      }
+      let hostname = request.hostname ?? "";
+      if (hostname[0] === "[" && hostname.endsWith("]")) {
+        hostname = request.hostname.slice(1, -1);
+      } else {
+        hostname = request.hostname;
+      }
+      const nodeHttpsOptions = {
+        headers: request.headers,
+        host: hostname,
+        method: request.method,
+        path,
+        port: request.port,
+        agent,
+        auth
+      };
+      const requestFunc = isSSL ? node_https.request : hRequest;
+      const req = requestFunc(nodeHttpsOptions, (res) => {
+        const httpResponse = new HttpResponse({
+          statusCode: res.statusCode || -1,
+          reason: res.statusMessage,
+          headers: getTransformedHeaders(res.headers),
+          body: res
+        });
+        resolve({ response: httpResponse });
+      });
+      req.on("error", (err) => {
+        if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+          reject(Object.assign(err, { name: "TimeoutError" }));
+        } else {
+          reject(err);
+        }
+      });
+      if (abortSignal) {
+        const onAbort = () => {
+          req.destroy();
+          const abortError = buildAbortError(abortSignal);
+          reject(abortError);
+        };
+        if (typeof abortSignal.addEventListener === "function") {
+          const signal = abortSignal;
+          signal.addEventListener("abort", onAbort, { once: true });
+          req.once("close", () => signal.removeEventListener("abort", onAbort));
+        } else {
+          abortSignal.onabort = onAbort;
+        }
+      }
+      const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
+      connectionTimeoutId = setConnectionTimeout(req, reject, config.connectionTimeout);
+      requestTimeoutId = setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console);
+      socketTimeoutId = setSocketTimeout(req, reject, config.socketTimeout);
+      const httpAgent = nodeHttpsOptions.agent;
+      if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+        keepAliveTimeoutId = setSocketKeepAlive(req, {
+          keepAlive: httpAgent.keepAlive,
+          keepAliveMsecs: httpAgent.keepAliveMsecs
+        });
+      }
+      writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => {
+        clearTimeouts();
+        return _reject(e);
+      });
+    });
+  }
+  updateHttpClientConfig(key, value) {
+    this.config = void 0;
+    this.configProvider = this.configProvider.then((config) => {
+      return {
+        ...config,
+        [key]: value
+      };
+    });
+  }
+  httpHandlerConfigs() {
+    return this.config ?? {};
+  }
+  resolveDefaultConfig(options) {
+    const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger } = options || {};
+    const keepAlive = true;
+    const maxSockets = 50;
+    return {
+      connectionTimeout,
+      requestTimeout,
+      socketTimeout,
+      socketAcquisitionWarningTimeout,
+      throwOnRequestTimeout,
+      httpAgentProvider: async () => {
+        const node_http = await import("http");
+        const { Agent, request } = node_http.default ?? node_http;
+        hRequest = request;
+        hAgent = Agent;
+        if (httpAgent instanceof hAgent || typeof httpAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpAgent;
+        }
+        return new hAgent({ keepAlive, maxSockets, ...httpAgent });
+      },
+      httpsAgent: (() => {
+        if (httpsAgent instanceof node_https.Agent || typeof httpsAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpsAgent;
+        }
+        return new node_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
+      })(),
+      logger
+    };
+  }
+};
+
+export {
+  NodeHttpHandler
+};

package/dist/chunk-T4PVQW5O.mjs

@@ -0,0 +1,124 @@
+// node_modules/@aws-sdk/nested-clients/package.json
+var package_default = {
+  name: "@aws-sdk/nested-clients",
+  version: "3.997.20",
+  description: "Nested clients for AWS SDK packages.",
+  main: "./dist-cjs/index.js",
+  module: "./dist-es/index.js",
+  types: "./dist-types/index.d.ts",
+  scripts: {
+    build: "yarn lint && concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
+    "build:cjs": "node ../../scripts/compilation/inline",
+    "build:es": "tsc -p tsconfig.es.json",
+    "build:include:deps": 'yarn g:turbo run build -F="$npm_package_name"',
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+    clean: "premove dist-cjs dist-es dist-types tsconfig.cjs.tsbuildinfo tsconfig.es.tsbuildinfo tsconfig.types.tsbuildinfo",
+    lint: "node ../../scripts/validation/submodules-linter.js",
+    test: "yarn g:vitest run",
+    "test:watch": "yarn g:vitest watch"
+  },
+  engines: {
+    node: ">=20.0.0"
+  },
+  sideEffects: false,
+  author: {
+    name: "AWS SDK for JavaScript Team",
+    url: "https://aws.amazon.com/sdk-for-javascript/"
+  },
+  license: "Apache-2.0",
+  dependencies: {
+    "@aws-crypto/sha256-browser": "5.2.0",
+    "@aws-crypto/sha256-js": "5.2.0",
+    "@aws-sdk/core": "^3.974.20",
+    "@aws-sdk/signature-v4-multi-region": "^3.996.34",
+    "@aws-sdk/types": "^3.973.12",
+    "@smithy/core": "^3.24.6",
+    "@smithy/fetch-http-handler": "^5.4.6",
+    "@smithy/node-http-handler": "^4.7.6",
+    "@smithy/types": "^4.14.3",
+    tslib: "^2.6.2"
+  },
+  devDependencies: {
+    concurrently: "7.0.0",
+    "downlevel-dts": "0.10.1",
+    premove: "4.0.0",
+    typescript: "~5.8.3"
+  },
+  typesVersions: {
+    "<4.5": {
+      "dist-types/*": [
+        "dist-types/ts3.4/*"
+      ]
+    }
+  },
+  files: [
+    "./cognito-identity.d.ts",
+    "./cognito-identity.js",
+    "./signin.d.ts",
+    "./signin.js",
+    "./sso-oidc.d.ts",
+    "./sso-oidc.js",
+    "./sso.d.ts",
+    "./sso.js",
+    "./sts.d.ts",
+    "./sts.js",
+    "dist-*/**"
+  ],
+  browser: {
+    "./dist-es/submodules/cognito-identity/runtimeConfig": "./dist-es/submodules/cognito-identity/runtimeConfig.browser",
+    "./dist-es/submodules/signin/runtimeConfig": "./dist-es/submodules/signin/runtimeConfig.browser",
+    "./dist-es/submodules/sso-oidc/runtimeConfig": "./dist-es/submodules/sso-oidc/runtimeConfig.browser",
+    "./dist-es/submodules/sso/runtimeConfig": "./dist-es/submodules/sso/runtimeConfig.browser",
+    "./dist-es/submodules/sts/runtimeConfig": "./dist-es/submodules/sts/runtimeConfig.browser"
+  },
+  "react-native": {},
+  homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients",
+  repository: {
+    type: "git",
+    url: "https://github.com/aws/aws-sdk-js-v3.git",
+    directory: "packages/nested-clients"
+  },
+  exports: {
+    "./package.json": "./package.json",
+    "./sso-oidc": {
+      types: "./dist-types/submodules/sso-oidc/index.d.ts",
+      module: "./dist-es/submodules/sso-oidc/index.js",
+      node: "./dist-cjs/submodules/sso-oidc/index.js",
+      import: "./dist-es/submodules/sso-oidc/index.js",
+      require: "./dist-cjs/submodules/sso-oidc/index.js"
+    },
+    "./sts": {
+      types: "./dist-types/submodules/sts/index.d.ts",
+      module: "./dist-es/submodules/sts/index.js",
+      node: "./dist-cjs/submodules/sts/index.js",
+      import: "./dist-es/submodules/sts/index.js",
+      require: "./dist-cjs/submodules/sts/index.js"
+    },
+    "./signin": {
+      types: "./dist-types/submodules/signin/index.d.ts",
+      module: "./dist-es/submodules/signin/index.js",
+      node: "./dist-cjs/submodules/signin/index.js",
+      import: "./dist-es/submodules/signin/index.js",
+      require: "./dist-cjs/submodules/signin/index.js"
+    },
+    "./cognito-identity": {
+      types: "./dist-types/submodules/cognito-identity/index.d.ts",
+      module: "./dist-es/submodules/cognito-identity/index.js",
+      node: "./dist-cjs/submodules/cognito-identity/index.js",
+      import: "./dist-es/submodules/cognito-identity/index.js",
+      require: "./dist-cjs/submodules/cognito-identity/index.js"
+    },
+    "./sso": {
+      types: "./dist-types/submodules/sso/index.d.ts",
+      module: "./dist-es/submodules/sso/index.js",
+      node: "./dist-cjs/submodules/sso/index.js",
+      import: "./dist-es/submodules/sso/index.js",
+      require: "./dist-cjs/submodules/sso/index.js"
+    }
+  }
+};
+
+export {
+  package_default
+};