@astrofoundry/pi-astro 0.16.1 → 0.18.1

package/node_modules/typebox/build/value/repair/from_record.mjs

@@ -1,33 +0,0 @@
-// deno-fmt-ignore-file
-import { IsAdditionalProperties } from '../../schema/types/index.mjs';
-import { RecordValue, RecordPattern } from '../../type/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { Create } from '../create/index.mjs';
-import { Check } from '../check/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromRecord(context, type, value) {
-    if (Check(context, type, value))
-        return value;
-    if (Guard.IsNull(value) || !Guard.IsObject(value) || Guard.IsArray(value))
-        return Create(context, type);
-    const recordKey = new RegExp(RecordPattern(type));
-    const recordValue = RecordValue(type);
-    const evaluatedKeys = new Set();
-    // PatternProperties
-    const result = {};
-    for (const [key, value_] of Guard.Entries(value)) {
-        if (!recordKey.test(key))
-            continue;
-        result[key] = FromType(context, recordValue, value_);
-        evaluatedKeys.add(key);
-    }
-    // AdditionalProperties
-    if (IsAdditionalProperties(type)) {
-        for (const key of Guard.Keys(value)) {
-            if (evaluatedKeys.has(key))
-                continue;
-            result[key] = FromType(context, type.additionalProperties, value[key]);
-        }
-    }
-    return result;
-}

package/node_modules/typebox/build/value/repair/from_ref.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TRef } from '../../type/index.mjs';
-export declare function FromRef(context: TProperties, type: TRef, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_ref.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-import { RepairError } from './error.mjs';
-export function FromRef(context, type, value) {
-    return Guard.HasPropertyKey(context, type.$ref)
-        ? FromType(context, context[type.$ref], value)
-        : (() => { throw new RepairError(context, type, value, 'Unable to de-reference target type'); })();
-}

package/node_modules/typebox/build/value/repair/from_template_literal.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TTemplateLiteral } from '../../type/index.mjs';
-export declare function FromTemplateLiteral(context: TProperties, type: TTemplateLiteral, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_template_literal.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromTemplateLiteral(context, type, value) {
-    const decoded = TemplateLiteralDecode(type.pattern);
-    return FromType(context, decoded, value);
-}

package/node_modules/typebox/build/value/repair/from_tuple.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TTuple } from '../../type/index.mjs';
-export declare function FromTuple(context: TProperties, schema: TTuple, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_tuple.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Check } from '../check/index.mjs';
-import { Create } from '../create/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromTuple(context, schema, value) {
-    if (Check(context, schema, value))
-        return value;
-    if (!Guard.IsArray(value))
-        return Create(context, schema);
-    return schema.items.map((schema, index) => FromType(context, schema, value[index]));
-}

package/node_modules/typebox/build/value/repair/from_type.d.mts

@@ -1,2 +0,0 @@
-import * as T from '../../type/index.mjs';
-export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_type.mjs

@@ -1,86 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-import * as T from '../../type/index.mjs';
-import { Check } from '../check/index.mjs';
-import { Create } from '../create/index.mjs';
-import { FromArray } from './from_array.mjs';
-import { FromBase } from './from_base.mjs';
-import { FromEnum } from './from_enum.mjs';
-import { FromIntersect } from './from_intersect.mjs';
-import { FromObject } from './from_object.mjs';
-import { FromRecord } from './from_record.mjs';
-import { FromRef } from './from_ref.mjs';
-import { FromTemplateLiteral } from './from_template_literal.mjs';
-import { FromTuple } from './from_tuple.mjs';
-import { FromUnion } from './from_union.mjs';
-import { FromUnknown } from './from_unknown.mjs';
-import { RepairError } from './error.mjs';
-// ------------------------------------------------------------------
-// AssertRepairableValue
-// ------------------------------------------------------------------
-function AssertRepairableValue(context, type, value) {
-    const unsupported = GlobalsGuard.IsDate(value)
-        || GlobalsGuard.IsMap(value)
-        || GlobalsGuard.IsSet(value)
-        || GlobalsGuard.IsTypeArray(value)
-        || Guard.IsConstructor(value)
-        || Guard.IsFunction(value);
-    if (unsupported) {
-        throw new RepairError(context, type, value, 'Value is not repairable');
-    }
-}
-// ------------------------------------------------------------------
-// AssertRepairableType
-// ------------------------------------------------------------------
-function AssertRepairableType(context, type, value) {
-    const unsupported = T.IsAsyncIterator(type)
-        || T.IsIterator(type)
-        || T.IsConstructor(type)
-        || T.IsFunction(type)
-        || T.IsNever(type)
-        || T.IsPromise(type);
-    if (unsupported) {
-        throw new RepairError(context, type, value, 'Type is not repairable');
-    }
-}
-// ------------------------------------------------------------------
-// FinalizeRepair
-//
-// When a type includes the ~refine modifier, a post-repair validation
-// check must be performed to ensure the repaired value satisfies the
-// refine constraint. This logic is implemented as part of FromType to
-// ensure the post-refine validation check is handled outside of
-// sub-schema constraint checking (i.e., at the top level).
-//
-// ------------------------------------------------------------------
-function FinalizeRepair(context, type, repaired) {
-    return T.IsRefine(type)
-        ? Check(context, type, repaired)
-            ? repaired
-            : Create(context, type)
-        : repaired;
-}
-// ------------------------------------------------------------------
-// FromType
-// ------------------------------------------------------------------
-export function FromType(context, type, value) {
-    // Base Repair
-    if (T.IsBase(type)) {
-        const repaired = FromBase(context, type, value);
-        return FinalizeRepair(context, type, repaired);
-    }
-    // Schema Repair
-    AssertRepairableValue(context, type, value);
-    AssertRepairableType(context, type, value);
-    const repaired = (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsEnum(type) ? FromEnum(context, type, value) :
-            T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                T.IsObject(type) ? FromObject(context, type, value) :
-                    T.IsRecord(type) ? FromRecord(context, type, value) :
-                        T.IsRef(type) ? FromRef(context, type, value) :
-                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                T.IsTuple(type) ? FromTuple(context, type, value) :
-                                    T.IsUnion(type) ? FromUnion(context, type, value) :
-                                        FromUnknown(context, type, value));
-    return FinalizeRepair(context, type, repaired);
-}

package/node_modules/typebox/build/value/repair/from_union.d.mts

@@ -1,2 +0,0 @@
-import { type TProperties, type TUnion } from '../../type/index.mjs';
-export declare function FromUnion(context: TProperties, type: TUnion, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_union.mjs

@@ -1,24 +0,0 @@
-// deno-fmt-ignore-file
-import { IsDefault } from '../../schema/types/index.mjs';
-import { Union } from '../../type/index.mjs';
-import { Flatten } from '../../type/engine/evaluate/index.mjs';
-import { Check } from '../check/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Create } from '../create/index.mjs';
-import { FromType } from './from_type.mjs';
-import { UnionScoreSelect } from '../shared/union_score_select.mjs';
-// ------------------------------------------------------------------
-// RepairUnion
-// ------------------------------------------------------------------
-function RepairUnion(context, type, value) {
-    const union = Union(Flatten(type.anyOf));
-    const schema = UnionScoreSelect(context, union, value);
-    return FromType(context, schema, value);
-}
-export function FromUnion(context, type, value) {
-    if (Check(context, type, value))
-        return Clone(value);
-    if (IsDefault(type))
-        return Create(context, type);
-    return RepairUnion(context, type, value);
-}

package/node_modules/typebox/build/value/repair/from_unknown.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TSchema } from '../../type/index.mjs';
-export declare function FromUnknown(context: TProperties, type: TSchema, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_unknown.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Check } from '../check/index.mjs';
-import { Create } from '../create/index.mjs';
-import { Convert } from '../convert/index.mjs';
-export function FromUnknown(context, type, value) {
-    if (Check(context, type, value))
-        return value;
-    const converted = Convert(context, type, value);
-    if (Check(context, type, converted))
-        return converted;
-    return Create(context, type);
-}

package/node_modules/typebox/build/value/repair/index.d.mts

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

package/node_modules/typebox/build/value/repair/index.mjs

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

package/node_modules/typebox/build/value/repair/repair.d.mts

@@ -1,17 +0,0 @@
-import type { TProperties, TSchema, Static } from '../../type/index.mjs';
-/**
- * Repairs a value to match the provided type. This function is intended for data migration
- * scenarios where existing values need to be migrating to an updated type. This function will
- * repair partially mismatched values by populating missing sub-properties and elements with
- * default structures derived from the type. If the value already conforms to the type, no
- * action is performed.
- */
-export declare function Repair<const Type extends TSchema>(type: Type, value: unknown): Static<Type>;
-/**
- * Repairs a value to match the provided type. This function is intended for data migration
- * scenarios where existing values need to be migrating to an updated type. This function will
- * repair partially mismatched values by populating missing sub-properties and elements with
- * default structures derived from the type. If the value already conforms to the type, no
- * action is performed.
- */
-export declare function Repair<Context extends TProperties, const Type extends TSchema>(context: Context, type: Type, value: unknown): Static<Type, Context>;

package/node_modules/typebox/build/value/repair/repair.mjs

@@ -1,20 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
-import { FromType } from './from_type.mjs';
-import { Assert } from '../assert/index.mjs';
-/**
- * Repairs a value to match the provided type. This function is intended for data migration
- * scenarios where existing values need to be migrating to an updated type. This function will
- * repair partially mismatched values by populating missing sub-properties and elements with
- * default structures derived from the type. If the value already conforms to the type, no
- * action is performed.
- */
-export function Repair(...args) {
-    const [context, type, value] = Arguments.Match(args, {
-        3: (context, type, value) => [context, type, value],
-        2: (type, value) => [{}, type, value],
-    });
-    const repaired = FromType(context, type, value);
-    Assert(context, type, repaired);
-    return repaired;
-}

package/node_modules/typebox/build/value/shared/index.d.mts

@@ -1,3 +0,0 @@
-export * from './optional_undefined.mjs';
-export * from './union_priority_sort.mjs';
-export * from './union_score_select.mjs';

package/node_modules/typebox/build/value/shared/index.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export * from './optional_undefined.mjs';
-export * from './union_priority_sort.mjs';
-export * from './union_score_select.mjs';

package/node_modules/typebox/build/value/shared/optional_undefined.d.mts

@@ -1,2 +0,0 @@
-import { type TSchema } from '../../type/index.mjs';
-export declare function IsOptionalUndefined(property: TSchema, key: PropertyKey, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/value/shared/optional_undefined.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsOptional } from '../../type/index.mjs';
-// ------------------------------------------------------------------
-// IsOptionalUndefined
-//
-// Indicates whether a key should be excluded from processing when it is 
-// defined as optional in the schema and its corresponding value is undefined. 
-// This case cannot be reliably distinguished from an omitted key, and therefore 
-// introduces ambiguity between a key that is not provided and one that is 
-// explicitly assigned an undefined value.
-// ------------------------------------------------------------------
-export function IsOptionalUndefined(property, key, value) {
-    return IsOptional(property) && Guard.IsUndefined(value[key]);
-}

package/node_modules/typebox/build/value/shared/union_priority_sort.d.mts

@@ -1,3 +0,0 @@
-import { type TSchema } from '../../type/index.mjs';
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];

package/node_modules/typebox/build/value/shared/union_priority_sort.mjs

@@ -1,36 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Compare } from '../../type/index.mjs';
-// ------------------------------------------------------------------
-// DeterministicCompare
-//
-// Provides a deterministic tie-break for schemas. This is used when
-// schemas are structurally disjoint or mutually inclusive. While
-// JSON serialization incurs a performance overhead, it serves as a
-// reliable mechanism to ensure stable ordering and preserves the
-// alphabetical alignment of named constants.
-//
-// ------------------------------------------------------------------
-function DeterministicCompare(left, right) {
-    return JSON.stringify(left).localeCompare(JSON.stringify(right));
-}
-// ------------------------------------------------------------------
-// UnionPrioritySort
-//
-// Performs a deterministic sort on Union members. By default, this
-// function ensures that narrow (more specific) types precede broader
-// types in the resulting array. The order can be reversed by setting
-// the order property to -1 which will reverse unions from broader
-// to more narrow.
-//
-// ------------------------------------------------------------------
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export function UnionPrioritySort(types, order = 1) {
-    return types.sort((left, right) => {
-        const result = Compare(left, right);
-        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
-            Guard.IsEqual(result, 'right-inside') ? 1 :
-                Guard.IsEqual(result, 'left-inside') ? -1 :
-                    DeterministicCompare(left, right)) * order;
-    });
-}

package/node_modules/typebox/build/value/shared/union_score_select.d.mts

@@ -1,3 +0,0 @@
-import { type TProperties, type TSchema, type TUnion } from '../../type/index.mjs';
-/** Scores Union variants and returns the best match for the given value */
-export declare function UnionScoreSelect(context: TProperties, type: TUnion, value: unknown): TSchema;

package/node_modules/typebox/build/value/shared/union_score_select.mjs

@@ -1,51 +0,0 @@
-// deno-fmt-ignore-file
-import { IsLiteral, IsObject, IsRef } from '../../type/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { Check } from '../check/index.mjs';
-// ------------------------------------------------------------------
-// Deref
-// ------------------------------------------------------------------
-function Deref(context, type, value) {
-    return IsRef(type)
-        ? Guard.HasPropertyKey(context, type.$ref)
-            ? Deref(context, context[type.$ref], value)
-            : (() => { throw new Error('Unable to Deref target'); })()
-        : type;
-}
-// ------------------------------------------------------------------
-// The following will score a schema against a value. For objects,
-// the score is the tally of points awarded for each property of
-// the value. Property points are (1.0 / propertyCount) to prevent
-// large property counts biasing results. Properties that match
-// literal values are maximally awarded as literals are typically
-// used as union discriminator fields.
-// ------------------------------------------------------------------
-function ScoreVariant(context, type, value) {
-    // scoring is only possible for object types.
-    if (!(IsObject(type) && Guard.IsObject(value)))
-        return 0;
-    const keys = Guard.Keys(value);
-    const entries = Guard.Entries(type.properties);
-    return entries.reduce((result, [key, schema]) => {
-        const literal = IsLiteral(schema) && Guard.IsEqual(schema.const, value[key]) ? 100 : 0;
-        const checks = Check(context, schema, value[key]) ? 10 : 0;
-        const exists = keys.includes(key) ? 1 : 0;
-        return result + (literal + checks + exists);
-    }, 0);
-}
-// ------------------------------------------------------------------
-// UnionScoreSelect
-// ------------------------------------------------------------------
-/** Scores Union variants and returns the best match for the given value */
-export function UnionScoreSelect(context, type, value) {
-    const schemas = type.anyOf.map((schema) => Deref(context, schema, value));
-    let [select, best] = [schemas[0], 0];
-    for (const schema of schemas) {
-        const score = ScoreVariant(context, schema, value);
-        if (score > best) {
-            select = schema;
-            best = score;
-        }
-    }
-    return select;
-}

package/node_modules/typebox/build/value/value.d.mts

@@ -1,16 +0,0 @@
-export { Assert } from './assert/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Decode, Encode, HasCodec } from './codec/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Errors } from './errors/index.mjs';
-export { Hash } from './hash/index.mjs';
-export { Mutate, type TMutable } from './mutate/index.mjs';
-export { Parse } from './parse/index.mjs';
-export { Diff, Patch } from './delta/index.mjs';
-export { Pointer } from './pointer/index.mjs';
-export { Repair } from './repair/index.mjs';

package/node_modules/typebox/build/value/value.mjs

@@ -1,16 +0,0 @@
-export { Assert } from './assert/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Decode, Encode, HasCodec } from './codec/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Errors } from './errors/index.mjs';
-export { Hash } from './hash/index.mjs';
-export { Mutate } from './mutate/index.mjs';
-export { Parse } from './parse/index.mjs';
-export { Diff, Patch } from './delta/index.mjs';
-export { Pointer } from './pointer/index.mjs';
-export { Repair } from './repair/index.mjs';

package/node_modules/typebox/license

@@ -1,23 +0,0 @@
-TypeBox
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2026 Haydn Paterson
-
-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.

package/node_modules/typebox/package.json

@@ -1,87 +0,0 @@
-{
-  "name": "typebox",
-  "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.38",
-  "keywords": [
-    "typescript",
-    "jsonschema"
-  ],
-  "license": "MIT",
-  "author": "sinclairzx81",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sinclairzx81/typebox"
-  },
-  "type": "module",
-  "types": "./build/index.d.mts",
-  "module": "./build/index.mjs",
-  "exports": {
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
-    "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
-    },
-    "./type": {
-      "import": "./build/type/index.mjs",
-      "default": "./build/type/index.mjs"
-    },
-    "./schema": {
-      "import": "./build/schema/index.mjs",
-      "default": "./build/schema/index.mjs"
-    },
-    "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
-    },
-    ".": {
-      "import": "./build/index.mjs",
-      "default": "./build/index.mjs"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
-      "error": [
-        "./build/error/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "system": [
-        "./build/system/index.d.mts"
-      ],
-      "format": [
-        "./build/format/index.d.mts"
-      ],
-      "type": [
-        "./build/type/index.d.mts"
-      ],
-      "schema": [
-        "./build/schema/index.d.mts"
-      ],
-      "value": [
-        "./build/value/index.d.mts"
-      ],
-      ".": [
-        "./build/index.d.mts"
-      ]
-    }
-  }
-}