@highstate/designer 0.4.5 → 0.5.0

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/type/json.mjs

@@ -1,221 +0,0 @@
-import { Any } from '../any/index.mjs';
-import { Array } from '../array/index.mjs';
-import { Boolean } from '../boolean/index.mjs';
-import { Composite } from '../composite/index.mjs';
-import { Const } from '../const/index.mjs';
-import { Enum } from '../enum/index.mjs';
-import { Exclude } from '../exclude/index.mjs';
-import { Extends } from '../extends/index.mjs';
-import { Extract } from '../extract/index.mjs';
-import { Index } from '../indexed/index.mjs';
-import { Integer } from '../integer/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
-import { KeyOf } from '../keyof/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { Mapped } from '../mapped/index.mjs';
-import { Never } from '../never/index.mjs';
-import { Not } from '../not/index.mjs';
-import { Null } from '../null/index.mjs';
-import { Module } from '../module/index.mjs';
-import { Number } from '../number/index.mjs';
-import { Object } from '../object/index.mjs';
-import { Omit } from '../omit/index.mjs';
-import { Optional } from '../optional/index.mjs';
-import { Partial } from '../partial/index.mjs';
-import { Pick } from '../pick/index.mjs';
-import { Readonly } from '../readonly/index.mjs';
-import { ReadonlyOptional } from '../readonly-optional/index.mjs';
-import { Record } from '../record/index.mjs';
-import { Recursive } from '../recursive/index.mjs';
-import { Ref } from '../ref/index.mjs';
-import { Required } from '../required/index.mjs';
-import { Rest } from '../rest/index.mjs';
-import { String } from '../string/index.mjs';
-import { TemplateLiteral } from '../template-literal/index.mjs';
-import { Transform } from '../transform/index.mjs';
-import { Tuple } from '../tuple/index.mjs';
-import { Union } from '../union/index.mjs';
-import { Unknown } from '../unknown/index.mjs';
-import { Unsafe } from '../unsafe/index.mjs';
-/** Json Type Builder with Static Resolution for TypeScript */
-export class JsonTypeBuilder {
-    // ------------------------------------------------------------------------
-    // Modifiers
-    // ------------------------------------------------------------------------
-    /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(type) {
-        return ReadonlyOptional(type);
-    }
-    /** `[Json]` Creates a Readonly property */
-    Readonly(type, enable) {
-        return Readonly(type, enable ?? true);
-    }
-    /** `[Json]` Creates a Optional property */
-    Optional(type, enable) {
-        return Optional(type, enable ?? true);
-    }
-    // ------------------------------------------------------------------------
-    // Types
-    // ------------------------------------------------------------------------
-    /** `[Json]` Creates an Any type */
-    Any(options) {
-        return Any(options);
-    }
-    /** `[Json]` Creates an Array type */
-    Array(items, options) {
-        return Array(items, options);
-    }
-    /** `[Json]` Creates a Boolean type */
-    Boolean(options) {
-        return Boolean(options);
-    }
-    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options) {
-        return Capitalize(schema, options);
-    }
-    /** `[Json]` Creates a Composite object type */
-    Composite(schemas, options) {
-        return Composite(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
-    }
-    /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options) {
-        return Const(value, options);
-    }
-    /** `[Json]` Creates a Enum type */
-    Enum(item, options) {
-        return Enum(item, options);
-    }
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options) {
-        return Exclude(unionType, excludedMembers, options);
-    }
-    /** `[Json]` Creates a Conditional type */
-    Extends(L, R, T, F, options) {
-        return Extends(L, R, T, F, options);
-    }
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract(type, union, options) {
-        return Extract(type, union, options);
-    }
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(type, key, options) {
-        return Index(type, key, options);
-    }
-    /** `[Json]` Creates an Integer type */
-    Integer(options) {
-        return Integer(options);
-    }
-    /** `[Json]` Creates an Intersect type */
-    Intersect(types, options) {
-        return Intersect(types, options);
-    }
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf(type, options) {
-        return KeyOf(type, options);
-    }
-    /** `[Json]` Creates a Literal type */
-    Literal(literalValue, options) {
-        return Literal(literalValue, options);
-    }
-    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(type, options) {
-        return Lowercase(type, options);
-    }
-    /** `[Json]` Creates a Mapped object type */
-    Mapped(key, map, options) {
-        return Mapped(key, map, options);
-    }
-    /** `[Json]` Creates a Type Definition Module. */
-    Module(properties) {
-        return Module(properties);
-    }
-    /** `[Json]` Creates a Never type */
-    Never(options) {
-        return Never(options);
-    }
-    /** `[Json]` Creates a Not type */
-    Not(type, options) {
-        return Not(type, options);
-    }
-    /** `[Json]` Creates a Null type */
-    Null(options) {
-        return Null(options);
-    }
-    /** `[Json]` Creates a Number type */
-    Number(options) {
-        return Number(options);
-    }
-    /** `[Json]` Creates an Object type */
-    Object(properties, options) {
-        return Object(properties, options);
-    }
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, selector, options) {
-        return Omit(schema, selector, options);
-    }
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial(type, options) {
-        return Partial(type, options);
-    }
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(type, key, options) {
-        return Pick(type, key, options);
-    }
-    /** `[Json]` Creates a Record type */
-    Record(key, value, options) {
-        return Record(key, value, options);
-    }
-    /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options) {
-        return Recursive(callback, options);
-    }
-    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-    Ref(...args) {
-        return Ref(args[0], args[1]);
-    }
-    /** `[Json]` Constructs a type where all properties are required */
-    Required(type, options) {
-        return Required(type, options);
-    }
-    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(type) {
-        return Rest(type);
-    }
-    /** `[Json]` Creates a String type */
-    String(options) {
-        return String(options);
-    }
-    /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options) {
-        return TemplateLiteral(unresolved, options);
-    }
-    /** `[Json]` Creates a Transform type */
-    Transform(type) {
-        return Transform(type);
-    }
-    /** `[Json]` Creates a Tuple type */
-    Tuple(types, options) {
-        return Tuple(types, options);
-    }
-    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(type, options) {
-        return Uncapitalize(type, options);
-    }
-    /** `[Json]` Creates a Union type */
-    Union(types, options) {
-        return Union(types, options);
-    }
-    /** `[Json]` Creates an Unknown type */
-    Unknown(options) {
-        return Unknown(options);
-    }
-    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options) {
-        return Unsafe(options);
-    }
-    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options) {
-        return Uppercase(schema, options);
-    }
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/type/type.mjs

@@ -1,62 +0,0 @@
-// ------------------------------------------------------------------
-// Type: Module
-// ------------------------------------------------------------------
-export { Any } from '../any/index.mjs';
-export { Argument } from '../argument/index.mjs';
-export { Array } from '../array/index.mjs';
-export { AsyncIterator } from '../async-iterator/index.mjs';
-export { Awaited } from '../awaited/index.mjs';
-export { BigInt } from '../bigint/index.mjs';
-export { Boolean } from '../boolean/index.mjs';
-export { Composite } from '../composite/index.mjs';
-export { Const } from '../const/index.mjs';
-export { Constructor } from '../constructor/index.mjs';
-export { ConstructorParameters } from '../constructor-parameters/index.mjs';
-export { Date } from '../date/index.mjs';
-export { Enum } from '../enum/index.mjs';
-export { Exclude } from '../exclude/index.mjs';
-export { Extends } from '../extends/index.mjs';
-export { Extract } from '../extract/index.mjs';
-export { Function } from '../function/index.mjs';
-export { Index } from '../indexed/index.mjs';
-export { InstanceType } from '../instance-type/index.mjs';
-export { Instantiate } from '../instantiate/index.mjs';
-export { Integer } from '../integer/index.mjs';
-export { Intersect } from '../intersect/index.mjs';
-export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
-export { Iterator } from '../iterator/index.mjs';
-export { KeyOf } from '../keyof/index.mjs';
-export { Literal } from '../literal/index.mjs';
-export { Mapped } from '../mapped/index.mjs';
-export { Module } from '../module/index.mjs';
-export { Never } from '../never/index.mjs';
-export { Not } from '../not/index.mjs';
-export { Null } from '../null/index.mjs';
-export { Number } from '../number/index.mjs';
-export { Object } from '../object/index.mjs';
-export { Omit } from '../omit/index.mjs';
-export { Optional } from '../optional/index.mjs';
-export { Parameters } from '../parameters/index.mjs';
-export { Partial } from '../partial/index.mjs';
-export { Pick } from '../pick/index.mjs';
-export { Promise } from '../promise/index.mjs';
-export { Readonly } from '../readonly/index.mjs';
-export { ReadonlyOptional } from '../readonly-optional/index.mjs';
-export { Record } from '../record/index.mjs';
-export { Recursive } from '../recursive/index.mjs';
-export { Ref } from '../ref/index.mjs';
-export { RegExp } from '../regexp/index.mjs';
-export { Required } from '../required/index.mjs';
-export { Rest } from '../rest/index.mjs';
-export { ReturnType } from '../return-type/index.mjs';
-export { String } from '../string/index.mjs';
-export { Symbol } from '../symbol/index.mjs';
-export { TemplateLiteral } from '../template-literal/index.mjs';
-export { Transform } from '../transform/index.mjs';
-export { Tuple } from '../tuple/index.mjs';
-export { Uint8Array } from '../uint8array/index.mjs';
-export { Undefined } from '../undefined/index.mjs';
-export { Union } from '../union/index.mjs';
-export { Unknown } from '../unknown/index.mjs';
-export { Unsafe } from '../unsafe/index.mjs';
-export { Void } from '../void/index.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/uint8array/index.mjs

@@ -1 +0,0 @@
-export * from './uint8array.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a Uint8Array type */
-export function Uint8Array(options) {
-    return CreateType({ [Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/undefined/index.mjs

@@ -1 +0,0 @@
-export * from './undefined.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a Undefined type */
-export function Undefined(options) {
-    return CreateType({ [Kind]: 'Undefined', type: 'undefined' }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/union/index.mjs

@@ -1,3 +0,0 @@
-export * from './union-evaluated.mjs';
-export * from './union-type.mjs';
-export * from './union.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs

@@ -1,5 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-export function UnionCreate(T, options) {
-    return CreateType({ [Kind]: 'Union', anyOf: T }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs

@@ -1,36 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { OptionalKind } from '../symbols/index.mjs';
-import { Discard } from '../discard/index.mjs';
-import { Never } from '../never/index.mjs';
-import { Optional } from '../optional/index.mjs';
-import { UnionCreate } from './union-create.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsOptional } from '../guard/kind.mjs';
-// prettier-ignore
-function IsUnionOptional(types) {
-    return types.some(type => IsOptional(type));
-}
-// prettier-ignore
-function RemoveOptionalFromRest(types) {
-    return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left);
-}
-// prettier-ignore
-function RemoveOptionalFromType(T) {
-    return (Discard(T, [OptionalKind]));
-}
-// prettier-ignore
-function ResolveUnion(types, options) {
-    const isOptional = IsUnionOptional(types);
-    return (isOptional
-        ? Optional(UnionCreate(RemoveOptionalFromRest(types), options))
-        : UnionCreate(RemoveOptionalFromRest(types), options));
-}
-/** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated(T, options) {
-    // prettier-ignore
-    return (T.length === 1 ? CreateType(T[0], options) :
-        T.length === 0 ? Never(options) :
-            ResolveUnion(T, options));
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/union/union-type.mjs

@@ -1 +0,0 @@
-import { Kind } from '../symbols/index.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/union/union.mjs

@@ -1,10 +0,0 @@
-import { Never } from '../never/index.mjs';
-import { CreateType } from '../create/type.mjs';
-import { UnionCreate } from './union-create.mjs';
-/** `[Json]` Creates a Union type */
-export function Union(types, options) {
-    // prettier-ignore
-    return (types.length === 0 ? Never(options) :
-        types.length === 1 ? CreateType(types[0], options) :
-            UnionCreate(types, options));
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/unknown/index.mjs

@@ -1 +0,0 @@
-export * from './unknown.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates an Unknown type */
-export function Unknown(options) {
-    return CreateType({ [Kind]: 'Unknown' }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/unsafe/index.mjs

@@ -1 +0,0 @@
-export * from './unsafe.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-export function Unsafe(options = {}) {
-    return CreateType({ [Kind]: options[Kind] ?? 'Unsafe' }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/void/index.mjs

@@ -1 +0,0 @@
-export * from './void.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/void/void.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a Void type */
-export function Void(options) {
-    return CreateType({ [Kind]: 'Void', type: 'void' }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs

@@ -1,158 +0,0 @@
-// --------------------------------------------------------------------------
-// Iterators
-// --------------------------------------------------------------------------
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-    return IsObject(value) && globalThis.Symbol.asyncIterator in value;
-}
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-    return IsObject(value) && globalThis.Symbol.iterator in value;
-}
-// --------------------------------------------------------------------------
-// Object Instances
-// --------------------------------------------------------------------------
-/** Returns true if this value is not an instance of a class */
-export function IsStandardObject(value) {
-    return IsObject(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null);
-}
-/** Returns true if this value is an instance of a class */
-export function IsInstanceObject(value) {
-    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
-}
-// --------------------------------------------------------------------------
-// JavaScript
-// --------------------------------------------------------------------------
-/** Returns true if this value is a Promise */
-export function IsPromise(value) {
-    return value instanceof globalThis.Promise;
-}
-/** Returns true if this value is a Date */
-export function IsDate(value) {
-    return value instanceof Date && globalThis.Number.isFinite(value.getTime());
-}
-/** Returns true if this value is an instance of Map<K, T> */
-export function IsMap(value) {
-    return value instanceof globalThis.Map;
-}
-/** Returns true if this value is an instance of Set<T> */
-export function IsSet(value) {
-    return value instanceof globalThis.Set;
-}
-/** Returns true if this value is RegExp */
-export function IsRegExp(value) {
-    return value instanceof globalThis.RegExp;
-}
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value) {
-    return globalThis.ArrayBuffer.isView(value);
-}
-/** Returns true if the value is a Int8Array */
-export function IsInt8Array(value) {
-    return value instanceof globalThis.Int8Array;
-}
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value) {
-    return value instanceof globalThis.Uint8Array;
-}
-/** Returns true if the value is a Uint8ClampedArray */
-export function IsUint8ClampedArray(value) {
-    return value instanceof globalThis.Uint8ClampedArray;
-}
-/** Returns true if the value is a Int16Array */
-export function IsInt16Array(value) {
-    return value instanceof globalThis.Int16Array;
-}
-/** Returns true if the value is a Uint16Array */
-export function IsUint16Array(value) {
-    return value instanceof globalThis.Uint16Array;
-}
-/** Returns true if the value is a Int32Array */
-export function IsInt32Array(value) {
-    return value instanceof globalThis.Int32Array;
-}
-/** Returns true if the value is a Uint32Array */
-export function IsUint32Array(value) {
-    return value instanceof globalThis.Uint32Array;
-}
-/** Returns true if the value is a Float32Array */
-export function IsFloat32Array(value) {
-    return value instanceof globalThis.Float32Array;
-}
-/** Returns true if the value is a Float64Array */
-export function IsFloat64Array(value) {
-    return value instanceof globalThis.Float64Array;
-}
-/** Returns true if the value is a BigInt64Array */
-export function IsBigInt64Array(value) {
-    return value instanceof globalThis.BigInt64Array;
-}
-/** Returns true if the value is a BigUint64Array */
-export function IsBigUint64Array(value) {
-    return value instanceof globalThis.BigUint64Array;
-}
-// --------------------------------------------------------------------------
-// PropertyKey
-// --------------------------------------------------------------------------
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-    return key in value;
-}
-// --------------------------------------------------------------------------
-// Standard
-// --------------------------------------------------------------------------
-/** Returns true of this value is an object type */
-export function IsObject(value) {
-    return value !== null && typeof value === 'object';
-}
-/** Returns true if this value is an array, but not a typed array */
-export function IsArray(value) {
-    return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
-}
-/** Returns true if this value is an undefined */
-export function IsUndefined(value) {
-    return value === undefined;
-}
-/** Returns true if this value is an null */
-export function IsNull(value) {
-    return value === null;
-}
-/** Returns true if this value is an boolean */
-export function IsBoolean(value) {
-    return typeof value === 'boolean';
-}
-/** Returns true if this value is an number */
-export function IsNumber(value) {
-    return typeof value === 'number';
-}
-/** Returns true if this value is an integer */
-export function IsInteger(value) {
-    return globalThis.Number.isInteger(value);
-}
-/** Returns true if this value is bigint */
-export function IsBigInt(value) {
-    return typeof value === 'bigint';
-}
-/** Returns true if this value is string */
-export function IsString(value) {
-    return typeof value === 'string';
-}
-/** Returns true if this value is a function */
-export function IsFunction(value) {
-    return typeof value === 'function';
-}
-/** Returns true if this value is a symbol */
-export function IsSymbol(value) {
-    return typeof value === 'symbol';
-}
-/** Returns true if this value is a value type such as number, string, boolean */
-export function IsValueType(value) {
-    // prettier-ignore
-    return (IsBigInt(value) ||
-        IsBoolean(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsString(value) ||
-        IsSymbol(value) ||
-        IsUndefined(value));
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/value/guard/index.mjs

@@ -1 +0,0 @@
-export * from './guard.mjs';