@xyo-network/sdk 7.0.3 → 7.0.5

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/index.d.ts

@@ -1,15 +0,0 @@
-export * from './Error.ts';
-export * from './isPayloadOfSchemaType.ts';
-export * from './isPayloadOfZodType.ts';
-export * from './Payload.ts';
-export * from './PayloadBundle.ts';
-export * from './PayloadFindFilter.ts';
-export * from './PayloadHashMap.ts';
-export * from './PayloadSet/index.ts';
-export * from './PayloadValidationFunction.ts';
-export * from './PayloadValueExpression.ts';
-export * from './PayloadZod.ts';
-export * from './Query.ts';
-export * from './Schema.ts';
-export * from './StorageMeta/index.ts';
-export * from './Timestamp.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/index.mjs

@@ -1,451 +0,0 @@
-// src/Error.ts
-import {
-  HashZod as HashZod2,
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import * as z4 from "zod/mini";
-
-// src/PayloadZod.ts
-import {
-  HashZod,
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory
-} from "@xylabs/sdk";
-import * as z3 from "zod/mini";
-
-// src/Schema.ts
-import { zodAsFactory, zodIsFactory } from "@xylabs/sdk";
-import * as z from "zod/mini";
-var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
-var SchemaZod = z.pipe(z.string().check(z.regex(SchemaRegEx)), z.transform((v) => v));
-var makeSchema = (value) => {
-  return z.pipe(z.literal(value), z.transform((x) => x));
-};
-var isSchema = zodIsFactory(SchemaZod);
-var asSchema = zodAsFactory(SchemaZod, "asSchema");
-var toSchema = zodAsFactory(SchemaZod, "toSchema");
-var PayloadSchema = asSchema("network.xyo.payload", true);
-var PayloadSchemaZod = z.literal(PayloadSchema);
-
-// src/StorageMeta/Sequence.ts
-import { AsObjectFactory } from "@xylabs/sdk";
-var isSequenceStorageMeta = (value) => {
-  return value?._sequence != void 0;
-};
-var asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta);
-var asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta);
-
-// src/StorageMeta/sequence/Parser.ts
-import {
-  assertEx,
-  isAddress,
-  toAddress,
-  toHex,
-  toUint8Array
-} from "@xylabs/sdk";
-
-// src/StorageMeta/sequence/Sequence.ts
-import { isHex } from "@xylabs/sdk";
-var isEpoch = (value) => {
-  return isHex(value) && value.length === SequenceConstants.epochBytes * 2;
-};
-var isNonce = (value) => {
-  return isHex(value) && value.length === SequenceConstants.nonceBytes * 2;
-};
-var isLocalSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
-};
-var isQualifiedSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
-};
-var isSequence = (value) => {
-  return isLocalSequence(value) || isQualifiedSequence(value);
-};
-var SequenceNonceComponentLengths = {
-  nonceIndexBytes: 4,
-  nonceHashBytes: 4
-};
-var SequenceComponentLengths = {
-  ...SequenceNonceComponentLengths,
-  epochBytes: 8,
-  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
-  addressBytes: 20
-};
-var SequenceComponentMinMax = {
-  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
-  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
-  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
-  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
-  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
-  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
-};
-var LocalSequenceConstants = {
-  ...SequenceComponentLengths,
-  ...SequenceComponentMinMax,
-  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
-  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
-  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
-};
-var QualifiedSequenceConstants = {
-  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
-  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
-  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
-};
-var SequenceConstants = {
-  ...LocalSequenceConstants,
-  ...QualifiedSequenceConstants
-};
-
-// src/StorageMeta/sequence/Parser.ts
-var SequenceParser = class _SequenceParser {
-  static privateConstructorKey = Date.now().toString();
-  data;
-  constructor(privateConstructorKey, hex) {
-    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    const paddedHex = toHex(hex, {
-      prefix: false,
-      bitLength: SequenceConstants[hex.length <= SequenceConstants.localSequenceBytes * 2 ? "localSequenceBytes" : "qualifiedSequenceBytes"] * 8
-    });
-    this.data = toUint8Array(paddedHex);
-  }
-  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
-    if (isSequence(timestampOrSequence)) {
-      if (nonceOrAddress) {
-        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
-        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
-        const combined = timestampOrSequence + nonceOrAddress;
-        return this.create(combined);
-      }
-      return this.create(timestampOrSequence);
-    }
-    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
-    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
-    const epoch = this.toEpoch(timestampOrSequence);
-    const nonce = nonceOrAddress === void 0 ? void 0 : this.toNonce(nonceOrAddress, index);
-    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
-    const hexString = epoch + nonce + addressHex;
-    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
-    return this.create(hexString);
-  }
-  static parse(value) {
-    const hex = toHex(value);
-    if (isSequence(hex)) {
-      return this.create(hex);
-    }
-    throw new Error(`Invalid sequence [${hex}]`);
-  }
-  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
-  static toEpoch(value) {
-    assertEx(
-      typeof value !== "number" || Number.isSafeInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (hex.length <= SequenceConstants.epochBytes * 2) {
-      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
-    }
-    if (isSequence(hex)) {
-      return hex.slice(0, SequenceConstants.epochBytes * 2);
-    }
-    throw new Error(`Value could not be converted to epoch [${hex}]`);
-  }
-  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
-  static toNonce(value, index = 0) {
-    assertEx(
-      typeof value !== "number" || Number.isSafeInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (isSequence(hex)) {
-      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
-    }
-    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
-    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
-    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
-  }
-  static create(hex) {
-    return new _SequenceParser(this.privateConstructorKey, hex);
-  }
-  get address() {
-    const start = SequenceConstants.localSequenceBytes;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get epoch() {
-    const start = 0;
-    const end = SequenceConstants.epochBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get localSequence() {
-    const start = 0;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get nonce() {
-    const start = SequenceConstants.epochBytes;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get qualifiedSequence() {
-    const start = 0;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-};
-
-// src/StorageMeta/sequence/Comparer.ts
-var local = (a, b) => {
-  const aa = SequenceParser.from(a);
-  const bb = SequenceParser.from(b);
-  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
-};
-var qualified = (a, b) => {
-  const aa = SequenceParser.from(a);
-  const bb = SequenceParser.from(b);
-  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0;
-};
-var SequenceComparer = { local, qualified };
-
-// src/StorageMeta/sequence/SequenceZod.ts
-import { HexRegExMinMax, toHex as toHex2 } from "@xylabs/sdk";
-import * as z2 from "zod/mini";
-var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z2.string().check(z2.regex(LocalSequenceRegex));
-var LocalSequenceFromStringZod = z2.pipe(
-  z2.string().check(z2.regex(LocalSequenceRegex)),
-  z2.transform((v) => toHex2(v))
-);
-var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z2.string().check(z2.regex(QualifiedSequenceRegex));
-var QualifiedSequenceFromStringZod = z2.pipe(
-  z2.string().check(z2.regex(QualifiedSequenceRegex)),
-  z2.transform((v) => toHex2(v))
-);
-var SequenceToStringZod = z2.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z2.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
-
-// src/PayloadZod.ts
-var HashMetaZod = z3.object({
-  _hash: HashZod,
-  _dataHash: HashZod
-});
-var isHashMeta = zodIsFactory2(HashMetaZod);
-var asHashMeta = zodAsFactory2(HashMetaZod, "asHashMeta");
-var toHashMeta = zodToFactory(HashMetaZod, "toHashMeta");
-var SequenceMetaZod = z3.object({ _sequence: SequenceFromStringZod });
-var isSequenceMeta = zodIsFactory2(SequenceMetaZod);
-var asSequenceMeta = zodAsFactory2(SequenceMetaZod, "asSequenceMeta");
-var toSequenceMeta = zodToFactory(SequenceMetaZod, "toSequenceMeta");
-var StorageMetaZod = z3.object({
-  _hash: HashZod,
-  _dataHash: HashZod,
-  _sequence: SequenceFromStringZod
-});
-var isStorageMeta = zodIsFactory2(StorageMetaZod);
-var asStorageMeta = zodAsFactory2(StorageMetaZod, "asStorageMeta");
-var toStorageMeta = zodToFactory(StorageMetaZod, "toStorageMeta");
-var PayloadZod = z3.object({ schema: SchemaZod });
-var isPayload = zodIsFactory2(PayloadZod);
-var asPayload = zodAsFactory2(PayloadZod, "asPayload");
-var toPayload = zodToFactory(PayloadZod, "toPayload");
-var AnyPayloadZod = z3.looseObject({ schema: SchemaZod });
-var isAnyPayload = zodIsFactory2(AnyPayloadZod);
-var asAnyPayload = zodAsFactory2(AnyPayloadZod, "asAnyPayload");
-var toAnyPayload = zodToFactory(AnyPayloadZod, "toAnyPayload");
-function WithStorageMetaZod(valueZod) {
-  return z3.object({ ...valueZod.shape, ...StorageMetaZod.shape });
-}
-function WithHashMetaZod(valueZod) {
-  return z3.object({ ...valueZod.shape, ...HashMetaZod.shape });
-}
-var PayloadZodStrict = z3.strictObject({ schema: SchemaZod });
-var PayloadZodLoose = z3.looseObject({ schema: SchemaZod });
-var WithHashMetaPayloadZodLoose = z3.extend(PayloadZodLoose, HashMetaZod.shape);
-var PayloadZodOfSchema = (schema) => z3.extend(PayloadZod, { schema: z3.literal(schema) });
-var PayloadZodStrictOfSchema = (schema) => z3.extend(PayloadZodStrict, { schema: z3.literal(schema) });
-var PayloadZodLooseOfSchema = (schema) => z3.extend(PayloadZodLoose, { schema: z3.literal(schema) });
-
-// src/Error.ts
-var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
-var ModuleErrorZod = z4.extend(PayloadZodOfSchema(ModuleErrorSchema), {
-  details: z4.optional(z4.custom()),
-  message: z4.optional(z4.string()),
-  name: z4.optional(z4.string()),
-  query: z4.optional(z4.union([HashZod2, SchemaZod]))
-});
-var isModuleError = zodIsFactory3(ModuleErrorZod);
-var asModuleError = zodAsFactory3(ModuleErrorZod, "asModuleError");
-var toModuleError = zodToFactory2(ModuleErrorZod, "toModuleError");
-
-// src/isPayloadOfSchemaType.ts
-function isPayloadOfSchemaType(schema) {
-  return (x) => isAnyPayload(x) && x?.schema === schema;
-}
-var isPayloadOfSchemaTypeWithSources = (schema) => {
-  return (x) => isPayloadOfSchemaType(schema)(x) && x.$sources != void 0 && Array.isArray(x.$sources);
-};
-var notPayloadOfSchemaType = (schema) => {
-  return (x) => !isAnyPayload(x) || x?.schema !== schema;
-};
-
-// src/isPayloadOfZodType.ts
-import { isDefined } from "@xylabs/sdk";
-import * as z5 from "zod/mini";
-function isPayloadOfZodType(zodSchema, schema) {
-  return (x) => {
-    if (!isAnyPayload(x)) return false;
-    if (isDefined(schema) && x.schema !== schema) return false;
-    const { schema: _, ...data } = x;
-    return z5.safeParse(zodSchema, data).success;
-  };
-}
-
-// src/PayloadBundle.ts
-import {
-  HashZod as HashZod3,
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory3
-} from "@xylabs/sdk";
-import * as z6 from "zod/mini";
-var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
-var PayloadBundleFieldsZod = z6.object({
-  payloads: z6.array(PayloadZodLoose),
-  root: HashZod3
-});
-var PayloadBundleZod = z6.extend(PayloadZodOfSchema(PayloadBundleSchema), PayloadBundleFieldsZod.shape);
-var isPayloadBundle = zodIsFactory4(PayloadBundleZod);
-var asPayloadBundle = zodAsFactory4(PayloadBundleZod, "asPayloadBundle");
-var asOptionalPayloadBundle = zodToFactory3(PayloadBundleZod, "asPayloadBundle");
-
-// src/PayloadSet/PayloadSetPayload.ts
-import {
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory4
-} from "@xylabs/sdk";
-import * as z7 from "zod/mini";
-
-// src/PayloadSet/PayloadSetSchema.ts
-var PayloadSetSchema = asSchema("network.xyo.payload.set", true);
-
-// src/PayloadSet/PayloadSetPayload.ts
-var stringNumberRecordZod = z7.record(z7.string(), z7.number());
-var PayloadSetZod = z7.object({
-  optional: z7.optional(stringNumberRecordZod),
-  required: z7.optional(stringNumberRecordZod)
-});
-var PayloadSetPayloadZod = z7.extend(PayloadZodOfSchema(PayloadSetSchema), PayloadSetZod.shape);
-var isPayloadSetPayload = zodIsFactory5(PayloadSetPayloadZod);
-var asPayloadSetPayload = zodAsFactory5(PayloadSetPayloadZod, "asPayloadSetPayload");
-var toPayloadSetPayload = zodToFactory4(PayloadSetPayloadZod, "toPayloadSetPayload");
-
-// src/Query.ts
-import { XyoAddressZod } from "../../address/neutral/index.mjs";
-import * as z8 from "zod/mini";
-var queryAddressZod = z8.union([XyoAddressZod, z8.array(XyoAddressZod)]);
-var maxFrequencyZod = z8.union([
-  z8.literal("once"),
-  z8.literal("second"),
-  z8.literal("minute"),
-  z8.literal("hour"),
-  z8.literal("day"),
-  z8.literal("week"),
-  z8.literal("month"),
-  z8.literal("year")
-]);
-var QueryFieldsZod = z8.object({
-  /** @field The addresses of the intended handlers */
-  address: z8.optional(queryAddressZod),
-  /** @field The maximum XYO that can be spent executing the query */
-  budget: z8.optional(z8.number()),
-  /** @field The frequency on which this query can be rerun */
-  maxFrequency: z8.optional(maxFrequencyZod),
-  /** @field The starting point for the bidding on the query */
-  minBid: z8.optional(z8.number())
-});
-export {
-  AnyPayloadZod,
-  HashMetaZod,
-  LocalSequenceConstants,
-  LocalSequenceFromStringZod,
-  LocalSequenceToStringZod,
-  ModuleErrorSchema,
-  ModuleErrorZod,
-  PayloadBundleFieldsZod,
-  PayloadBundleSchema,
-  PayloadBundleZod,
-  PayloadSchema,
-  PayloadSchemaZod,
-  PayloadSetPayloadZod,
-  PayloadSetSchema,
-  PayloadSetZod,
-  PayloadZod,
-  PayloadZodLoose,
-  PayloadZodLooseOfSchema,
-  PayloadZodOfSchema,
-  PayloadZodStrict,
-  PayloadZodStrictOfSchema,
-  QualifiedSequenceConstants,
-  QualifiedSequenceFromStringZod,
-  QualifiedSequenceToStringZod,
-  QueryFieldsZod,
-  SchemaRegEx,
-  SchemaZod,
-  SequenceComparer,
-  SequenceComponentLengths,
-  SequenceComponentMinMax,
-  SequenceConstants,
-  SequenceFromStringZod,
-  SequenceMetaZod,
-  SequenceNonceComponentLengths,
-  SequenceParser,
-  SequenceToStringZod,
-  StorageMetaZod,
-  WithHashMetaPayloadZodLoose,
-  WithHashMetaZod,
-  WithStorageMetaZod,
-  asAnyPayload,
-  asHashMeta,
-  asModuleError,
-  asOptionalPayloadBundle,
-  asOptionalSequenceStorageMeta,
-  asPayload,
-  asPayloadBundle,
-  asPayloadSetPayload,
-  asSchema,
-  asSequenceMeta,
-  asSequenceStorageMeta,
-  asStorageMeta,
-  isAnyPayload,
-  isEpoch,
-  isHashMeta,
-  isLocalSequence,
-  isModuleError,
-  isNonce,
-  isPayload,
-  isPayloadBundle,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-  isPayloadOfZodType,
-  isPayloadSetPayload,
-  isQualifiedSequence,
-  isSchema,
-  isSequence,
-  isSequenceMeta,
-  isSequenceStorageMeta,
-  isStorageMeta,
-  makeSchema,
-  notPayloadOfSchemaType,
-  toAnyPayload,
-  toHashMeta,
-  toModuleError,
-  toPayload,
-  toPayloadSetPayload,
-  toSchema,
-  toSequenceMeta,
-  toStorageMeta
-};

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/isPayloadOfSchemaType.d.ts

@@ -1,4 +0,0 @@
-import type { Payload, WithSources } from './Payload.ts';
-export declare function isPayloadOfSchemaType<T extends Payload = never>(schema: T['schema']): (x?: unknown) => x is T;
-export declare const isPayloadOfSchemaTypeWithSources: <T extends Payload = never>(schema: T["schema"]) => (x?: unknown) => x is WithSources<T>;
-export declare const notPayloadOfSchemaType: <T extends Payload = never>(schema: T["schema"]) => (x?: unknown) => x is T;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/isPayloadOfZodType.d.ts

@@ -1,11 +0,0 @@
-import * as z from 'zod/mini';
-import type { Payload } from './Payload.ts';
-/**
- * Checks if a value is a payload of a specific Zod type.
- * @param zodSchema The Zod schema to validate against
- * @param schema The schema string to match against the payload. Optional in
- * case you want to validate any payload matching the Zod schema or in case
- * schema is part of the Zod schema.
- * @returns A function that checks if a value is a payload of the specified Zod type
- */
-export declare function isPayloadOfZodType<T extends Payload = never, S extends z.core.$ZodObject = z.core.$ZodObject>(zodSchema: S, schema?: T['schema']): (x?: unknown) => x is T;

package/dist/_pkg/sdk-protocol/_pkg/payload-plugin/neutral/Plugin.d.ts

@@ -1,18 +0,0 @@
-import type { Validator } from '@xylabs/sdk';
-import type { PayloadBuilder } from '../../payload-builder/neutral/index.ts';
-import type { Payload } from '../../payload-model/neutral/index.ts';
-import type { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
-import type { SomeJSONSchema } from 'ajv/dist/types/json-schema.js';
-import type { $ZodType } from 'zod/v4/core';
-export type PayloadPluginFunc<TPayload extends Payload = Payload> = () => PayloadPlugin<TPayload>;
-export interface PayloadPlugin<TPayload extends Payload = Payload> {
-    build?: () => PayloadBuilder<TPayload>;
-    /** @deprecated use zod instead */
-    jsonSchema?: SomeJSONSchema;
-    schema: TPayload['schema'];
-    /** @deprecated use zod defaults instead */
-    template?: () => Partial<TPayload>;
-    validate?: (payload: Payload) => Validator<Payload>;
-    wrap?: (payload: Payload) => PayloadWrapper;
-    zod?: $ZodType;
-}

package/dist/_pkg/sdk-protocol/_pkg/payload-plugin/neutral/Resolver.d.ts

@@ -1,25 +0,0 @@
-import type { Validator } from '@xylabs/sdk';
-import type { Payload } from '../../payload-model/neutral/index.ts';
-import type { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
-import type { PayloadPlugin } from './Plugin.ts';
-export declare class PayloadPluginResolver {
-    schema: "network.xyo.payload" & {
-        readonly __schema: true;
-    };
-    protected _plugins: Record<string, PayloadPlugin>;
-    protected defaultPlugin: PayloadPlugin;
-    constructor(
-    /** @param plugins The initial set of plugins */
-    plugins?: PayloadPlugin<Payload>[], 
-    /** @param defaultPlugin Specifies the plugin to be used if no plugins resolve */
-    defaultPlugin?: PayloadPlugin<Payload>);
-    /** @description Create list of plugins, optionally filtered by ability to witness/divine */
-    plugins(): PayloadPlugin<Payload>[];
-    register<TPlugin extends PayloadPlugin = PayloadPlugin>(plugin: TPlugin): this;
-    resolve(schema?: string): PayloadPlugin;
-    resolve(payload: Payload): PayloadPlugin;
-    /** @description Create list of schema, optionally filtered by ability to witness/divine */
-    schemas(): string[];
-    validate(payload: Payload): Validator<Payload> | undefined;
-    wrap(payload: Payload): PayloadWrapper<Payload> | undefined;
-}

package/dist/_pkg/sdk-protocol/_pkg/payload-plugin/neutral/createPlugin.d.ts

@@ -1,4 +0,0 @@
-import type { Payload, Schema } from '../../payload-model/neutral/index.ts';
-import type { PayloadPlugin } from './Plugin.ts';
-export declare const defaultPayloadPluginFunctions: <T extends Payload>(schema: Schema) => PayloadPlugin<T>;
-export declare const createPayloadPlugin: <TPayload extends Payload = Payload>(plugin: PayloadPlugin<TPayload>) => PayloadPlugin<TPayload>;

package/dist/_pkg/sdk-protocol/_pkg/payload-plugin/neutral/index.d.ts

@@ -1,3 +0,0 @@
-export * from './createPlugin.ts';
-export * from './Plugin.ts';
-export * from './Resolver.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-plugin/neutral/index.mjs

@@ -1,66 +0,0 @@
-// src/createPlugin.ts
-import { assertEx } from "@xylabs/sdk";
-import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
-import { PayloadValidator } from "../../payload-validator/neutral/index.mjs";
-import { PayloadWrapper } from "../../payload-wrapper/neutral/index.mjs";
-var defaultPayloadPluginFunctions = (schema) => {
-  return {
-    build: () => {
-      return new PayloadBuilder({ schema });
-    },
-    schema,
-    validate: (payload) => {
-      return new PayloadValidator(payload);
-    },
-    wrap: (payload) => {
-      return PayloadWrapper.wrap(payload);
-    }
-  };
-};
-var createPayloadPlugin = (plugin) => {
-  return {
-    ...defaultPayloadPluginFunctions(assertEx(plugin.schema, () => "schema field required to create plugin")),
-    ...plugin
-  };
-};
-
-// src/Resolver.ts
-import { isDefined } from "@xylabs/sdk";
-import { PayloadSchema } from "../../payload-model/neutral/index.mjs";
-var PayloadPluginResolver = class {
-  schema = PayloadSchema;
-  _plugins = {};
-  defaultPlugin;
-  constructor(plugins, defaultPlugin = createPayloadPlugin({ schema: PayloadSchema })) {
-    for (const plugin of plugins ?? []) this.register(plugin);
-    this.defaultPlugin = defaultPlugin;
-  }
-  /** @description Create list of plugins, optionally filtered by ability to witness/divine */
-  plugins() {
-    const result = Object.values(this._plugins);
-    return result;
-  }
-  register(plugin) {
-    this._plugins[plugin.schema] = plugin;
-    return this;
-  }
-  resolve(value) {
-    return isDefined(value) ? this._plugins[typeof value === "string" ? value : value.schema] ?? this.defaultPlugin : this.defaultPlugin;
-  }
-  /** @description Create list of schema, optionally filtered by ability to witness/divine */
-  schemas() {
-    const result = Array.from(Object.values(this._plugins), (value) => value.schema);
-    return result;
-  }
-  validate(payload) {
-    return this.resolve(payload).validate?.(payload);
-  }
-  wrap(payload) {
-    return this.resolve(payload).wrap?.(payload);
-  }
-};
-export {
-  PayloadPluginResolver,
-  createPayloadPlugin,
-  defaultPayloadPluginFunctions
-};

package/dist/_pkg/sdk-protocol/_pkg/payload-validator/neutral/Validator.d.ts

@@ -1,17 +0,0 @@
-import type { Promisable, Validator } from '@xylabs/sdk';
-import { ValidatorBase } from '@xylabs/sdk';
-import type { Payload } from '../../payload-model/neutral/index.ts';
-export interface AllValidator {
-    all(): Error[];
-}
-export type AllValidatorFactory = (schema: string) => AllValidator;
-export declare class PayloadValidator<T extends Payload = Payload> extends ValidatorBase<T> implements Validator<T> {
-    protected static schemaNameValidatorFactory: AllValidatorFactory;
-    private _schemaValidator?;
-    protected payload: Payload;
-    constructor(payload: T);
-    static setSchemaNameValidatorFactory(factory: AllValidatorFactory): void;
-    get schemaValidator(): AllValidator;
-    schemaName(): Error[];
-    validate(): Promisable<Error[]>;
-}

package/dist/_pkg/sdk-protocol/_pkg/payload-validator/neutral/index.d.ts

@@ -1 +0,0 @@
-export * from './Validator.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-validator/neutral/index.mjs

@@ -1,39 +0,0 @@
-// src/Validator.ts
-import { isUndefined, ValidatorBase } from "@xylabs/sdk";
-import { SchemaNameValidator } from "../../schema-name-validator/neutral/index.mjs";
-var defaultSchemaNameValidatorFactory = (schema) => new SchemaNameValidator(schema);
-var PayloadValidator = class _PayloadValidator extends ValidatorBase {
-  static schemaNameValidatorFactory = defaultSchemaNameValidatorFactory;
-  _schemaValidator;
-  payload;
-  constructor(payload) {
-    super(payload);
-    this.payload = payload;
-  }
-  static setSchemaNameValidatorFactory(factory) {
-    this.schemaNameValidatorFactory = factory;
-  }
-  get schemaValidator() {
-    this._schemaValidator = this._schemaValidator ?? _PayloadValidator.schemaNameValidatorFactory?.(this.payload.schema);
-    if (isUndefined(this._schemaValidator)) {
-      console.warn(`No schema name validator set [${this.payload.schema}]`);
-    }
-    return this._schemaValidator;
-  }
-  schemaName() {
-    const errors = [];
-    if (this.obj.schema === void 0) {
-      errors.push(new Error("schema missing"));
-    } else {
-      errors.push(...this.schemaValidator?.all() ?? []);
-    }
-    return errors;
-  }
-  validate() {
-    const errors = [...this.schemaName()];
-    return errors;
-  }
-};
-export {
-  PayloadValidator
-};