trilean 0.0.0 → 1.0.0

package/dist/json-value-B1Hjjjri.d.cts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+//#region src/json-value.d.ts
+/**
+ * A JSON value with no further meaning imposed by this schema -- used for every opaque payload (reference keys, table identifiers, collection references, delegation payloads). "Opaque" means "uninterpreted by this package", not "untyped" -- every one of these must still be plain, serialisable JSON.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+//#endregion
+export { JsonValueSchema as n, JsonValue as t };

package/dist/json-value-B1Hjjjri.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+//#region src/json-value.d.ts
+/**
+ * A JSON value with no further meaning imposed by this schema -- used for every opaque payload (reference keys, table identifiers, collection references, delegation payloads). "Opaque" means "uninterpreted by this package", not "untyped" -- every one of these must still be plain, serialisable JSON.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+//#endregion
+export { JsonValueSchema as n, JsonValue as t };

package/dist/json-value.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/json-value.ts
+const JsonValueSchema = zod.z.lazy(() => zod.z.union([
+	zod.z.string(),
+	zod.z.number(),
+	zod.z.boolean(),
+	zod.z.null(),
+	zod.z.array(JsonValueSchema),
+	zod.z.record(zod.z.string(), JsonValueSchema)
+]));
+//#endregion
+exports.JsonValueSchema = JsonValueSchema;

package/dist/json-value.d.cts

@@ -0,0 +1,2 @@
+import { n as JsonValueSchema, t as JsonValue } from "./json-value-B1Hjjjri.cjs";
+export { JsonValue, JsonValueSchema };

package/dist/json-value.d.ts

@@ -0,0 +1,2 @@
+import { n as JsonValueSchema, t as JsonValue } from "./json-value-B1Hjjjri.js";
+export { JsonValue, JsonValueSchema };

package/dist/json-value.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+//#region src/json-value.ts
+const JsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(JsonValueSchema),
+	z.record(z.string(), JsonValueSchema)
+]));
+//#endregion
+export { JsonValueSchema };

package/dist/resolvers.d.cts

@@ -0,0 +1,28 @@
+import { ComputedValue } from "./computed-value.cjs";
+import { t as JsonValue } from "./json-value-B1Hjjjri.cjs";
+//#region src/resolvers.d.ts
+/**
+ * An opaque, purely in-process value supplied by the caller, never itself part of the serialised tree and never required to be JSON-serialisable. Descending into a `fold` or a quantifier replaces the context for the sub-node's evaluation with the single resolved item.
+ */
+type EvaluationContext = unknown;
+type Resolution = {
+  found: true;
+  value: ComputedValue;
+} | {
+  found: false;
+};
+/**
+ * Three independent points of extension, each supplied separately by the embedding consumer, each treated as pure data to hand over -- never as resolver logic living inside the schema itself. Plain TypeScript interfaces, not Zod schemas: resolvers are never serialised, only ever supplied in-process at evaluation time.
+ */
+interface Resolvers {
+  /** Resolver 1 -- a single opaque key to a single value (`reference`). */
+  resolveValue: (key: JsonValue, context: EvaluationContext) => Promise<Resolution>;
+  /** Resolver 2 -- an opaque table identifier plus computed keys to a single value (`lookup`). */
+  resolveLookup: (table: JsonValue, keys: readonly ComputedValue[], context: EvaluationContext) => Promise<Resolution>;
+  /** Resolver 3 -- an opaque collection reference to a concrete list of items (`fold`/`some`/`every`). Always returns the full candidate list; narrowing which items participate is handled uniformly, after resolution, by each node's own `filter`. */
+  resolveCollection: (collection: JsonValue, context: EvaluationContext) => Promise<unknown[]>;
+  /** Optional, separate from the three core contracts -- see the `delegate` node kind. */
+  resolveDelegate?: (system: string, payload: JsonValue, context: EvaluationContext) => Promise<Resolution>;
+}
+//#endregion
+export { EvaluationContext, Resolution, Resolvers };

package/dist/resolvers.d.ts

@@ -0,0 +1,28 @@
+import { ComputedValue } from "./computed-value.js";
+import { t as JsonValue } from "./json-value-B1Hjjjri.js";
+//#region src/resolvers.d.ts
+/**
+ * An opaque, purely in-process value supplied by the caller, never itself part of the serialised tree and never required to be JSON-serialisable. Descending into a `fold` or a quantifier replaces the context for the sub-node's evaluation with the single resolved item.
+ */
+type EvaluationContext = unknown;
+type Resolution = {
+  found: true;
+  value: ComputedValue;
+} | {
+  found: false;
+};
+/**
+ * Three independent points of extension, each supplied separately by the embedding consumer, each treated as pure data to hand over -- never as resolver logic living inside the schema itself. Plain TypeScript interfaces, not Zod schemas: resolvers are never serialised, only ever supplied in-process at evaluation time.
+ */
+interface Resolvers {
+  /** Resolver 1 -- a single opaque key to a single value (`reference`). */
+  resolveValue: (key: JsonValue, context: EvaluationContext) => Promise<Resolution>;
+  /** Resolver 2 -- an opaque table identifier plus computed keys to a single value (`lookup`). */
+  resolveLookup: (table: JsonValue, keys: readonly ComputedValue[], context: EvaluationContext) => Promise<Resolution>;
+  /** Resolver 3 -- an opaque collection reference to a concrete list of items (`fold`/`some`/`every`). Always returns the full candidate list; narrowing which items participate is handled uniformly, after resolution, by each node's own `filter`. */
+  resolveCollection: (collection: JsonValue, context: EvaluationContext) => Promise<unknown[]>;
+  /** Optional, separate from the three core contracts -- see the `delegate` node kind. */
+  resolveDelegate?: (system: string, payload: JsonValue, context: EvaluationContext) => Promise<Resolution>;
+}
+//#endregion
+export { EvaluationContext, Resolution, Resolvers };

package/dist/tree.cjs

@@ -0,0 +1,289 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_computed_value = require("./computed-value.cjs");
+const require_json_value = require("./json-value.cjs");
+let zod = require("zod");
+//#region src/tree.ts
+const ComparisonOperatorSchema = zod.z.enum([
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"eq",
+	"neq"
+]);
+const TextComparisonOperatorSchema = zod.z.enum([
+	"equals",
+	"notEquals",
+	"matches",
+	"notMatches"
+]);
+const MembershipOperatorSchema = zod.z.enum(["in", "notIn"]);
+const ArithmeticOperatorSchema = zod.z.enum([
+	"add",
+	"subtract",
+	"multiply",
+	"divide",
+	"power",
+	"modulo"
+]);
+const NotNodeSchema = zod.z.object({
+	kind: zod.z.literal("not"),
+	get operand() {
+		return PredicateNodeSchema;
+	}
+});
+const AndNodeSchema = zod.z.object({
+	kind: zod.z.literal("and"),
+	get left() {
+		return PredicateNodeSchema;
+	},
+	get right() {
+		return PredicateNodeSchema;
+	}
+});
+const OrNodeSchema = zod.z.object({
+	kind: zod.z.literal("or"),
+	get left() {
+		return PredicateNodeSchema;
+	},
+	get right() {
+		return PredicateNodeSchema;
+	}
+});
+const AllOfNodeSchema = zod.z.object({
+	kind: zod.z.literal("allOf"),
+	get operands() {
+		return zod.z.array(PredicateNodeSchema);
+	}
+});
+const AnyOfNodeSchema = zod.z.object({
+	kind: zod.z.literal("anyOf"),
+	get operands() {
+		return zod.z.array(PredicateNodeSchema);
+	}
+});
+const CompareNodeSchema = zod.z.object({
+	kind: zod.z.literal("compare"),
+	op: ComparisonOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const TextCompareNodeSchema = zod.z.object({
+	kind: zod.z.literal("textCompare"),
+	op: TextComparisonOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const MemberOfNodeSchema = zod.z.object({
+	kind: zod.z.literal("memberOf"),
+	op: MembershipOperatorSchema,
+	get operand() {
+		return ExpressionNodeSchema;
+	},
+	get candidates() {
+		return zod.z.array(ExpressionNodeSchema);
+	}
+});
+const ExistsNodeSchema = zod.z.object({
+	kind: zod.z.literal("exists"),
+	get operand() {
+		return ExpressionNodeSchema;
+	}
+});
+const SomeNodeSchema = zod.z.object({
+	kind: zod.z.literal("some"),
+	collection: require_json_value.JsonValueSchema,
+	get item() {
+		return PredicateNodeSchema;
+	},
+	get filter() {
+		return PredicateNodeSchema.optional();
+	}
+});
+const EveryNodeSchema = zod.z.object({
+	kind: zod.z.literal("every"),
+	collection: require_json_value.JsonValueSchema,
+	get item() {
+		return PredicateNodeSchema;
+	},
+	get filter() {
+		return PredicateNodeSchema.optional();
+	}
+});
+const PredicateNodeSchema = zod.z.discriminatedUnion("kind", [
+	NotNodeSchema,
+	AndNodeSchema,
+	OrNodeSchema,
+	AllOfNodeSchema,
+	AnyOfNodeSchema,
+	CompareNodeSchema,
+	TextCompareNodeSchema,
+	MemberOfNodeSchema,
+	ExistsNodeSchema,
+	SomeNodeSchema,
+	EveryNodeSchema
+]);
+const NumberLiteralNodeSchema = zod.z.object({
+	kind: zod.z.literal("numberLiteral"),
+	value: zod.z.number(),
+	unit: require_computed_value.UnitSchema.optional()
+});
+const TextLiteralNodeSchema = zod.z.object({
+	kind: zod.z.literal("textLiteral"),
+	value: zod.z.string()
+});
+const InstantLiteralNodeSchema = zod.z.object({
+	kind: zod.z.literal("instantLiteral"),
+	/** ISO-8601 timestamp. */
+	value: zod.z.string()
+});
+const DurationLiteralNodeSchema = zod.z.object({
+	kind: zod.z.literal("durationLiteral"),
+	value: zod.z.number(),
+	unit: require_computed_value.DurationUnitSchema
+});
+const ReferenceNodeSchema = zod.z.object({
+	kind: zod.z.literal("reference"),
+	key: require_json_value.JsonValueSchema,
+	unit: require_computed_value.UnitSchema.optional()
+});
+const ArithmeticNodeSchema = zod.z.object({
+	kind: zod.z.literal("arithmetic"),
+	op: ArithmeticOperatorSchema,
+	get left() {
+		return ExpressionNodeSchema;
+	},
+	get right() {
+		return ExpressionNodeSchema;
+	}
+});
+const NegateNodeSchema = zod.z.object({
+	kind: zod.z.literal("negate"),
+	get operand() {
+		return ExpressionNodeSchema;
+	}
+});
+const CallNodeSchema = zod.z.object({
+	kind: zod.z.literal("call"),
+	fn: zod.z.string(),
+	get args() {
+		return zod.z.array(ExpressionNodeSchema);
+	}
+});
+const LookupNodeSchema = zod.z.object({
+	kind: zod.z.literal("lookup"),
+	table: require_json_value.JsonValueSchema,
+	get keys() {
+		return zod.z.array(ExpressionNodeSchema);
+	}
+});
+const ConditionalCaseSchema = zod.z.object({
+	get when() {
+		return PredicateNodeSchema;
+	},
+	get then() {
+		return ExpressionNodeSchema;
+	}
+});
+const ConditionalNodeSchema = zod.z.object({
+	kind: zod.z.literal("conditional"),
+	get cases() {
+		return zod.z.array(ConditionalCaseSchema);
+	},
+	get fallback() {
+		return ExpressionNodeSchema;
+	}
+});
+const FoldCombinerSchema = zod.z.discriminatedUnion("mode", [
+	zod.z.object({
+		mode: zod.z.literal("max"),
+		get item() {
+			return ExpressionNodeSchema;
+		}
+	}),
+	zod.z.object({
+		mode: zod.z.literal("min"),
+		get item() {
+			return ExpressionNodeSchema;
+		}
+	}),
+	zod.z.object({
+		mode: zod.z.literal("reduce"),
+		get initial() {
+			return ExpressionNodeSchema;
+		},
+		get combine() {
+			return ExpressionNodeSchema;
+		}
+	})
+]);
+const FoldNodeSchema = zod.z.object({
+	kind: zod.z.literal("fold"),
+	collection: require_json_value.JsonValueSchema,
+	get filter() {
+		return PredicateNodeSchema.optional();
+	},
+	combiner: FoldCombinerSchema
+});
+const AccumulatorNodeSchema = zod.z.object({ kind: zod.z.literal("accumulator") });
+const DelegateNodeSchema = zod.z.object({
+	kind: zod.z.literal("delegate"),
+	system: zod.z.string(),
+	payload: require_json_value.JsonValueSchema
+});
+const ExpressionNodeSchema = zod.z.discriminatedUnion("kind", [
+	NumberLiteralNodeSchema,
+	TextLiteralNodeSchema,
+	InstantLiteralNodeSchema,
+	DurationLiteralNodeSchema,
+	ReferenceNodeSchema,
+	ArithmeticNodeSchema,
+	NegateNodeSchema,
+	CallNodeSchema,
+	LookupNodeSchema,
+	ConditionalNodeSchema,
+	FoldNodeSchema,
+	AccumulatorNodeSchema,
+	DelegateNodeSchema
+]);
+//#endregion
+exports.AccumulatorNodeSchema = AccumulatorNodeSchema;
+exports.AllOfNodeSchema = AllOfNodeSchema;
+exports.AndNodeSchema = AndNodeSchema;
+exports.AnyOfNodeSchema = AnyOfNodeSchema;
+exports.ArithmeticNodeSchema = ArithmeticNodeSchema;
+exports.ArithmeticOperatorSchema = ArithmeticOperatorSchema;
+exports.CallNodeSchema = CallNodeSchema;
+exports.CompareNodeSchema = CompareNodeSchema;
+exports.ComparisonOperatorSchema = ComparisonOperatorSchema;
+exports.ConditionalCaseSchema = ConditionalCaseSchema;
+exports.ConditionalNodeSchema = ConditionalNodeSchema;
+exports.DelegateNodeSchema = DelegateNodeSchema;
+exports.DurationLiteralNodeSchema = DurationLiteralNodeSchema;
+exports.EveryNodeSchema = EveryNodeSchema;
+exports.ExistsNodeSchema = ExistsNodeSchema;
+exports.ExpressionNodeSchema = ExpressionNodeSchema;
+exports.FoldCombinerSchema = FoldCombinerSchema;
+exports.FoldNodeSchema = FoldNodeSchema;
+exports.InstantLiteralNodeSchema = InstantLiteralNodeSchema;
+exports.LookupNodeSchema = LookupNodeSchema;
+exports.MemberOfNodeSchema = MemberOfNodeSchema;
+exports.MembershipOperatorSchema = MembershipOperatorSchema;
+exports.NegateNodeSchema = NegateNodeSchema;
+exports.NotNodeSchema = NotNodeSchema;
+exports.NumberLiteralNodeSchema = NumberLiteralNodeSchema;
+exports.OrNodeSchema = OrNodeSchema;
+exports.PredicateNodeSchema = PredicateNodeSchema;
+exports.ReferenceNodeSchema = ReferenceNodeSchema;
+exports.SomeNodeSchema = SomeNodeSchema;
+exports.TextCompareNodeSchema = TextCompareNodeSchema;
+exports.TextComparisonOperatorSchema = TextComparisonOperatorSchema;
+exports.TextLiteralNodeSchema = TextLiteralNodeSchema;