@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/arktype/out/variants/object.d.ts

@@ -0,0 +1,107 @@
+import type { BaseMappedPropInner, OptionalMappedPropInner, Prop } from "@ark/schema";
+import type { arkGet, arkIndexableOf, arkKeyOf, array, ErrorType, inferred, intersectUnion, JsonStructure, Key, listable, merge, optionalKeyOf, show, toArkKey } from "@ark/util";
+import type { Default, withDefault } from "../attributes.ts";
+import type { type } from "../keywords/keywords.ts";
+import type { ArrayType } from "./array.ts";
+import type { BaseType } from "./base.ts";
+import type { instantiateType } from "./instantiate.ts";
+/** @ts-ignore cast variance */
+interface Type<out t extends object = object, $ = {}> extends BaseType<t, $> {
+    readonly(): t extends array ? ArrayType<{
+        readonly [i in keyof t]: t[i];
+    }, $> : Type<{
+        readonly [k in keyof t]: t[k];
+    }, $>;
+    keyof(): instantiateType<arkKeyOf<t>, $>;
+    /**
+     * Get the `Type` of a property of this `Type<object>`.
+     * @example type({ foo: "string" }).get("foo") // Type<string>
+     */
+    get<const k1 extends arkIndexableOf<t>, r = instantiateType<arkGet<t, k1>, $>>(k1: k1 | type.cast<k1>): r extends infer _ ? _ : never;
+    get<const k1 extends arkIndexableOf<t>, const k2 extends arkIndexableOf<arkGet<t, k1>>, r = instantiateType<arkGet<arkGet<t, k1>, k2>, $>>(k1: k1 | type.cast<k1>, k2: k2 | type.cast<k2>): r extends infer _ ? _ : never;
+    get<const k1 extends arkIndexableOf<t>, const k2 extends arkIndexableOf<arkGet<t, k1>>, const k3 extends arkIndexableOf<arkGet<arkGet<t, k1>, k2>>, r = instantiateType<arkGet<arkGet<arkGet<t, k1>, k2>, k3>, $>>(k1: k1 | type.cast<k1>, k2: k2 | type.cast<k2>, k3: k3 | type.cast<k3>): r extends infer _ ? _ : never;
+    /**
+     * Create a copy of this `Type` with only the specified properties.
+     * @example type({ foo: "string", bar: "number" }).pick("foo") // Type<{ foo: string }>
+     */
+    pick<const key extends arkKeyOf<t> = never>(...keys: (key | type.cast<key>)[]): Type<{
+        [k in keyof t as Extract<toArkKey<t, k>, key>]: t[k];
+    }, $>;
+    /**
+     * Create a copy of this `Type` with all properties except the specified ones.
+     * @example type({ foo: "string", bar: "number" }).omit("foo") // Type<{ bar: number }>
+     */
+    omit<const key extends arkKeyOf<t> = never>(...keys: (key | type.cast<key>)[]): Type<{
+        [k in keyof t as Exclude<toArkKey<t, k>, key>]: t[k];
+    }, $>;
+    /**
+     * Merge another `Type` definition, overriding properties of this `Type` with the duplicate keys.
+     * @example type({ a: "1", b: "2" }).merge({ b: "3", c: "4" }) // Type<{ a: 1, b: 3, c: 4 }>
+     */
+    merge<const def, inferredDef = type.infer<def, $>, r = Type<merge<t, inferredDef>, $>>(def: type.validate<def, $> & (inferredDef extends object ? unknown : ErrorType<[NonObjectMergeErrorMessage, actual: inferredDef]>)): r extends infer _ ? _ : never;
+    /**
+     * Create a copy of this `Type` with all properties required.
+     * @example const T = type({ "foo?"": "string" }).required() // Type<{ foo: string }>
+     */
+    required(): Type<{
+        [k in keyof t]-?: t[k];
+    }, $>;
+    /**
+     * Create a copy of this `Type` with all properties optional.
+     * @example: const T = type({ foo: "string" }).optional() // Type<{ foo?: string }>
+     */
+    partial(): Type<{
+        [k in keyof t]?: t[k];
+    }, $>;
+    map<transformed extends listable<MappedTypeProp>, r = Type<constructMapped<t, transformed>, $>>(flatMapEntry: (entry: typePropOf<t, $>) => transformed): r extends infer _ ? _ : never;
+    /**
+     * List of property info of this `Type<object>`.
+     * @example type({ foo: "string = "" }).props // [{ kind: "required", key: "foo", value: Type<string>, default: "" }]
+     */
+    props: array<typePropOf<t, $>>;
+}
+type typePropOf<o, $> = keyof o extends infer k ? k extends keyof o ? typeProp<o, k, $> : never : never;
+type typeProp<o, k extends keyof o, $, t = o[k] & ({} | null)> = t extends Default<infer t, infer defaultValue> ? DefaultedTypeProp<k & Key, t, defaultValue, $> : BaseTypeProp<k extends optionalKeyOf<o> ? "optional" : "required", k & Key, t, $>;
+export interface BaseTypeProp<kind extends Prop.Kind = Prop.Kind, k extends Key = Key, 
+/** @ts-ignore cast variance */
+out v = unknown, $ = {}> {
+    kind: kind;
+    key: k;
+    value: instantiateType<v, $>;
+    meta: ArkEnv.meta;
+    toJSON: () => JsonStructure;
+}
+export interface DefaultedTypeProp<k extends Key = Key, v = unknown, defaultValue = v, $ = {}> extends BaseTypeProp<"optional", k, v, $> {
+    default: defaultValue;
+}
+type MappedTypeProp<k extends Key = Key, v = unknown> = BaseMappedTypeProp<k, v> | OptionalMappedTypeProp<k, v>;
+type BaseMappedTypeProp<k extends Key, v> = merge<BaseMappedPropInner, {
+    key: k;
+    value: type.cast<v>;
+}>;
+type OptionalMappedTypeProp<k extends Key, v> = merge<OptionalMappedPropInner, {
+    key: k;
+    value: type.cast<v>;
+    default?: v;
+}>;
+type constructMapped<t, transformed extends listable<MappedTypeProp>> = show<intersectUnion<fromTypeProps<t, transformed extends array ? transformed : [transformed]>>>;
+type fromTypeProps<t, props extends array<MappedTypeProp>> = show<{
+    [prop in props[number] as Extract<applyHomomorphicOptionality<t, prop>, {
+        kind: "required";
+    }>["key"]]: prop["value"][inferred];
+} & {
+    [prop in props[number] as Extract<applyHomomorphicOptionality<t, prop>, {
+        kind: "optional";
+        default?: never;
+    }>["key"]]?: prop["value"][inferred];
+} & {
+    [prop in props[number] as Extract<applyHomomorphicOptionality<t, prop>, {
+        kind: "optional";
+        default: unknown;
+    }>["key"]]: withDefault<prop["value"][inferred], prop["default" & keyof prop]>;
+}>;
+export type NonObjectMergeErrorMessage = "Merged type must be an object";
+type applyHomomorphicOptionality<t, prop extends MappedTypeProp> = prop["kind"] extends string ? prop : prop & {
+    kind: prop["key"] extends optionalKeyOf<t> ? "optional" : "required";
+};
+export type { Type as ObjectType };

package/node_modules/arktype/out/variants/object.js

@@ -0,0 +1 @@
+export {};

package/node_modules/arktype/out/variants/string.d.ts

@@ -0,0 +1,15 @@
+import type { ExactLength, ExclusiveNumericRangeSchema, InclusiveNumericRangeSchema, Pattern } from "@ark/schema";
+import type { regex } from "arkregex";
+import type { BaseType } from "./base.ts";
+/** @ts-ignore cast variance */
+interface Type<out t extends string = string, $ = {}> extends BaseType<t, $> {
+    matching<const schema extends Pattern.Schema>(schema: schema): schema extends string ? Type<regex.infer<schema>, $> : schema extends {
+        rule: infer pattern extends string;
+    } ? Type<regex.infer<pattern>, $> : this;
+    atLeastLength(schema: InclusiveNumericRangeSchema): this;
+    atMostLength(schema: InclusiveNumericRangeSchema): this;
+    moreThanLength(schema: ExclusiveNumericRangeSchema): this;
+    lessThanLength(schema: ExclusiveNumericRangeSchema): this;
+    exactlyLength(schema: ExactLength.Schema): this;
+}
+export type { Type as StringType };

package/node_modules/arktype/out/variants/string.js

@@ -0,0 +1 @@
+export {};

package/node_modules/arktype/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "arktype",
+  "description": "TypeScript's 1:1 validator, optimized from editor to runtime",
+  "version": "2.1.29",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arktypeio/arktype.git",
+    "directory": "ark/type"
+  },
+  "author": {
+    "name": "David Blass",
+    "email": "david@arktype.io",
+    "url": "https://arktype.io"
+  },
+  "type": "module",
+  "main": "./out/index.js",
+  "types": "./out/index.d.ts",
+  "exports": {
+    ".": {
+      "ark-ts": "./index.ts",
+      "default": "./out/index.js"
+    },
+    "./config": {
+      "ark-ts": "./config.ts",
+      "default": "./out/config.js"
+    },
+    "./internal/*.ts": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    },
+    "./internal/*.js": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    }
+  },
+  "files": [
+    "out"
+  ],
+  "dependencies": {
+    "@ark/util": "0.56.0",
+    "@ark/schema": "0.56.0",
+    "arkregex": "0.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "ts ../repo/build.ts",
+    "test": "ts ../repo/testPackage.ts; pnpm testIntegration",
+    "testIntegration": "pnpm testSimpleConfig && pnpm testAllConfig && pnpm testOnFailConfig && pnpm testEoptConfig",
+    "testSimpleConfig": "ts ./__tests__/integration/testSimpleConfig.ts",
+    "testAllConfig": "ts ./__tests__/integration/testAllConfig.ts",
+    "testOnFailConfig": "ts ./__tests__/integration/testOnFailConfig.ts",
+    "testEoptConfig": "ts ./__tests__/integration/testEoptConfig.ts"
+  }
+}

package/node_modules/debug/LICENSE

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2018-2021 Josh Junon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the 'Software'), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+