@rippling/rippling-sdk 0.2.0-alpha.105 → 0.2.0-alpha.106

package/lib/charts/guards.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRuleNode = assertRuleNode;
+exports.literalValue = literalValue;
+const errors_1 = require("./errors.js");
+/**
+ * Runtime validation for one node of a deserialized, untrusted rule tree, shared
+ * by `evaluate` and `describe`. A rule can arrive from JSON that TypeScript never
+ * checked, so `null`, a non-object, or a node without a string `kind` would throw
+ * a native `TypeError` on the first field read — skipping the `ChartRuleError`
+ * escape hatch a caller relies on. Validate before reading fields.
+ */
+const SCALAR_TYPES = new Set(['number', 'string', 'boolean']);
+/**
+ * Assert `node` is shaped like a rule node — an object carrying a string `kind`.
+ * An unrecognised `kind` is *not* rejected here; that is the caller's `switch`
+ * default (`UnknownNodeError`), the deliberate "configured in code" signal.
+ */
+function assertRuleNode(node) {
+    if (node === null ||
+        typeof node !== 'object' ||
+        Array.isArray(node) ||
+        typeof node.kind !== 'string') {
+        throw new errors_1.MalformedRuleError('a rule node must be an object with a string "kind"');
+    }
+}
+/**
+ * Read a `literal` node's `value`, rejecting a missing or non-scalar one. Without
+ * this, `{ kind: 'literal' }` resolves to `undefined` and slips past the caller.
+ */
+function literalValue(node) {
+    const { value } = node;
+    if (value === null || SCALAR_TYPES.has(typeof value)) {
+        return value;
+    }
+    throw new errors_1.MalformedRuleError(`a literal must carry a scalar value, got ${value === undefined ? 'undefined' : typeof value}`);
+}
+//# sourceMappingURL=guards.js.map

package/lib/charts/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/lib/charts/guards.ts"],"names":[],"mappings":";;AAkBA,wCASC;AAMD,oCAQC;AAzCD,wCAA8C;AAG9C;;;;;;GAMG;AAEH,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAEnF;;;;GAIG;AACH,SAAgB,cAAc,CAAC,IAAa;IAC1C,IACE,IAAI,KAAK,IAAI;QACb,OAAO,IAAI,KAAK,QAAQ;QACxB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QACnB,OAAQ,IAA2B,CAAC,IAAI,KAAK,QAAQ,EACrD,CAAC;QACD,MAAM,IAAI,2BAAkB,CAAC,oDAAoD,CAAC,CAAC;IACrF,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,IAAyB;IACpD,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IACvB,IAAI,KAAK,KAAK,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,KAAe,CAAC;IACzB,CAAC;IACD,MAAM,IAAI,2BAAkB,CAC1B,4CAA4C,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAC/F,CAAC;AACJ,CAAC"}

package/lib/charts/guards.mjs

@@ -0,0 +1,34 @@
+import { MalformedRuleError } from "./errors.mjs";
+/**
+ * Runtime validation for one node of a deserialized, untrusted rule tree, shared
+ * by `evaluate` and `describe`. A rule can arrive from JSON that TypeScript never
+ * checked, so `null`, a non-object, or a node without a string `kind` would throw
+ * a native `TypeError` on the first field read — skipping the `ChartRuleError`
+ * escape hatch a caller relies on. Validate before reading fields.
+ */
+const SCALAR_TYPES = new Set(['number', 'string', 'boolean']);
+/**
+ * Assert `node` is shaped like a rule node — an object carrying a string `kind`.
+ * An unrecognised `kind` is *not* rejected here; that is the caller's `switch`
+ * default (`UnknownNodeError`), the deliberate "configured in code" signal.
+ */
+export function assertRuleNode(node) {
+    if (node === null ||
+        typeof node !== 'object' ||
+        Array.isArray(node) ||
+        typeof node.kind !== 'string') {
+        throw new MalformedRuleError('a rule node must be an object with a string "kind"');
+    }
+}
+/**
+ * Read a `literal` node's `value`, rejecting a missing or non-scalar one. Without
+ * this, `{ kind: 'literal' }` resolves to `undefined` and slips past the caller.
+ */
+export function literalValue(node) {
+    const { value } = node;
+    if (value === null || SCALAR_TYPES.has(typeof value)) {
+        return value;
+    }
+    throw new MalformedRuleError(`a literal must carry a scalar value, got ${value === undefined ? 'undefined' : typeof value}`);
+}
+//# sourceMappingURL=guards.mjs.map

package/lib/charts/guards.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.mjs","sourceRoot":"","sources":["../../src/lib/charts/guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,qBAAiB;AAG9C;;;;;;GAMG;AAEH,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAEnF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAa;IAC1C,IACE,IAAI,KAAK,IAAI;QACb,OAAO,IAAI,KAAK,QAAQ;QACxB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QACnB,OAAQ,IAA2B,CAAC,IAAI,KAAK,QAAQ,EACrD,CAAC;QACD,MAAM,IAAI,kBAAkB,CAAC,oDAAoD,CAAC,CAAC;IACrF,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,IAAyB;IACpD,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IACvB,IAAI,KAAK,KAAK,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,KAAe,CAAC;IACzB,CAAC;IACD,MAAM,IAAI,kBAAkB,CAC1B,4CAA4C,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAC/F,CAAC;AACJ,CAAC"}

package/lib/charts/schema.d.mts

@@ -0,0 +1,101 @@
+/** Stable identifier for the published contract, versioned by the tag. */
+export declare const CHART_RULE_SCHEMA_ID: string;
+/**
+ * JSON Schema (2020-12) for the `{$rule}` placeholder and its closed node set.
+ *
+ * This is the contract. A consumer that keeps its own rule evaluator (rather
+ * than importing `evaluate`) can validate against this so the two never drift —
+ * every kind and operand shape the builders can emit is described here.
+ */
+export declare const chartRuleSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: string;
+    readonly title: "Chart rule placeholder";
+    readonly description: "A rule tree the chart agent emits into a chart option, marked with $rule.";
+    readonly type: "object";
+    readonly required: readonly ["$rule", "channel"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly $rule: {
+            readonly $ref: "#/$defs/ifElse";
+        };
+        readonly channel: {
+            readonly const: "color";
+        };
+    };
+    readonly $defs: {
+        readonly scalar: {
+            readonly type: readonly ["number", "string", "boolean", "null"];
+        };
+        readonly node: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/ref";
+            }, {
+                readonly $ref: "#/$defs/literal";
+            }, {
+                readonly $ref: "#/$defs/comparison";
+            }, {
+                readonly $ref: "#/$defs/ifElse";
+            }];
+        };
+        readonly ref: {
+            readonly type: "object";
+            readonly required: readonly ["kind"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "value";
+                };
+            };
+        };
+        readonly literal: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "value"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "literal";
+                };
+                readonly value: {
+                    readonly $ref: "#/$defs/scalar";
+                };
+            };
+        };
+        readonly comparison: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "left", "right"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly enum: readonly ["equals", "isNot", "lessThan", "greaterThan", "lessOrEqual", "greaterOrEqual"];
+                };
+                readonly left: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly right: {
+                    readonly $ref: "#/$defs/node";
+                };
+            };
+        };
+        readonly ifElse: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "cond", "then", "else"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "ifElse";
+                };
+                readonly cond: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly then: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly else: {
+                    readonly $ref: "#/$defs/node";
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.mts.map

package/lib/charts/schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.mts","sourceRoot":"","sources":["../../src/lib/charts/schema.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,QAAqE,CAAC;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DlB,CAAC"}

package/lib/charts/schema.d.ts

@@ -0,0 +1,101 @@
+/** Stable identifier for the published contract, versioned by the tag. */
+export declare const CHART_RULE_SCHEMA_ID: string;
+/**
+ * JSON Schema (2020-12) for the `{$rule}` placeholder and its closed node set.
+ *
+ * This is the contract. A consumer that keeps its own rule evaluator (rather
+ * than importing `evaluate`) can validate against this so the two never drift —
+ * every kind and operand shape the builders can emit is described here.
+ */
+export declare const chartRuleSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: string;
+    readonly title: "Chart rule placeholder";
+    readonly description: "A rule tree the chart agent emits into a chart option, marked with $rule.";
+    readonly type: "object";
+    readonly required: readonly ["$rule", "channel"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly $rule: {
+            readonly $ref: "#/$defs/ifElse";
+        };
+        readonly channel: {
+            readonly const: "color";
+        };
+    };
+    readonly $defs: {
+        readonly scalar: {
+            readonly type: readonly ["number", "string", "boolean", "null"];
+        };
+        readonly node: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/ref";
+            }, {
+                readonly $ref: "#/$defs/literal";
+            }, {
+                readonly $ref: "#/$defs/comparison";
+            }, {
+                readonly $ref: "#/$defs/ifElse";
+            }];
+        };
+        readonly ref: {
+            readonly type: "object";
+            readonly required: readonly ["kind"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "value";
+                };
+            };
+        };
+        readonly literal: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "value"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "literal";
+                };
+                readonly value: {
+                    readonly $ref: "#/$defs/scalar";
+                };
+            };
+        };
+        readonly comparison: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "left", "right"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly enum: readonly ["equals", "isNot", "lessThan", "greaterThan", "lessOrEqual", "greaterOrEqual"];
+                };
+                readonly left: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly right: {
+                    readonly $ref: "#/$defs/node";
+                };
+            };
+        };
+        readonly ifElse: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "cond", "then", "else"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "ifElse";
+                };
+                readonly cond: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly then: {
+                    readonly $ref: "#/$defs/node";
+                };
+                readonly else: {
+                    readonly $ref: "#/$defs/node";
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/lib/charts/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lib/charts/schema.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,QAAqE,CAAC;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DlB,CAAC"}

package/lib/charts/schema.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chartRuleSchema = exports.CHART_RULE_SCHEMA_ID = void 0;
+const types_1 = require("./types.js");
+/** Stable identifier for the published contract, versioned by the tag. */
+exports.CHART_RULE_SCHEMA_ID = `https://rippling.com/schemas/${types_1.CHART_RULE_CONTRACT_VERSION}.json`;
+/**
+ * JSON Schema (2020-12) for the `{$rule}` placeholder and its closed node set.
+ *
+ * This is the contract. A consumer that keeps its own rule evaluator (rather
+ * than importing `evaluate`) can validate against this so the two never drift —
+ * every kind and operand shape the builders can emit is described here.
+ */
+exports.chartRuleSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: exports.CHART_RULE_SCHEMA_ID,
+    title: 'Chart rule placeholder',
+    description: 'A rule tree the chart agent emits into a chart option, marked with $rule.',
+    type: 'object',
+    required: ['$rule', 'channel'],
+    additionalProperties: false,
+    properties: {
+        // A colour rule's top-level tree is the conditional-value form (`when(...)`),
+        // matching what `color()` builds and accepts. A bare ref/comparison/literal
+        // resolves to a number/boolean/constant, not a colour decision.
+        $rule: { $ref: '#/$defs/ifElse' },
+        channel: { const: 'color' },
+    },
+    $defs: {
+        scalar: { type: ['number', 'string', 'boolean', 'null'] },
+        node: {
+            oneOf: [
+                { $ref: '#/$defs/ref' },
+                { $ref: '#/$defs/literal' },
+                { $ref: '#/$defs/comparison' },
+                { $ref: '#/$defs/ifElse' },
+            ],
+        },
+        ref: {
+            type: 'object',
+            required: ['kind'],
+            additionalProperties: false,
+            properties: { kind: { const: 'value' } },
+        },
+        literal: {
+            type: 'object',
+            required: ['kind', 'value'],
+            additionalProperties: false,
+            properties: { kind: { const: 'literal' }, value: { $ref: '#/$defs/scalar' } },
+        },
+        comparison: {
+            type: 'object',
+            required: ['kind', 'left', 'right'],
+            additionalProperties: false,
+            properties: {
+                kind: { enum: ['equals', 'isNot', 'lessThan', 'greaterThan', 'lessOrEqual', 'greaterOrEqual'] },
+                left: { $ref: '#/$defs/node' },
+                right: { $ref: '#/$defs/node' },
+            },
+        },
+        ifElse: {
+            type: 'object',
+            required: ['kind', 'cond', 'then', 'else'],
+            additionalProperties: false,
+            properties: {
+                kind: { const: 'ifElse' },
+                cond: { $ref: '#/$defs/node' },
+                then: { $ref: '#/$defs/node' },
+                else: { $ref: '#/$defs/node' },
+            },
+        },
+    },
+};
+//# sourceMappingURL=schema.js.map

package/lib/charts/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/lib/charts/schema.ts"],"names":[],"mappings":";;;AAAA,sCAAsD;AAEtD,0EAA0E;AAC7D,QAAA,oBAAoB,GAAG,gCAAgC,mCAA2B,OAAO,CAAC;AAEvG;;;;;;GAMG;AACU,QAAA,eAAe,GAAG;IAC7B,OAAO,EAAE,8CAA8C;IACvD,GAAG,EAAE,4BAAoB;IACzB,KAAK,EAAE,wBAAwB;IAC/B,WAAW,EAAE,2EAA2E;IACxF,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC;IAC9B,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,8EAA8E;QAC9E,4EAA4E;QAC5E,gEAAgE;QAChE,KAAK,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;QACjC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE;KAC5B;IACD,KAAK,EAAE;QACL,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE;QACzD,IAAI,EAAE;YACJ,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,aAAa,EAAE;gBACvB,EAAE,IAAI,EAAE,iBAAiB,EAAE;gBAC3B,EAAE,IAAI,EAAE,oBAAoB,EAAE;gBAC9B,EAAE,IAAI,EAAE,gBAAgB,EAAE;aAC3B;SACF;QACD,GAAG,EAAE;YACH,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,CAAC;YAClB,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;SACzC;QACD,OAAO,EAAE;YACP,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;YAC3B,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE;SAC9E;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;YACnC,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE;gBACV,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,CAAC,EAAE;gBAC/F,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,KAAK,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;aAChC;SACF;QACD,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAC1C,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE;gBACV,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;gBACzB,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;aAC/B;SACF;KACF;CACO,CAAC"}

package/lib/charts/schema.mjs

@@ -0,0 +1,71 @@
+import { CHART_RULE_CONTRACT_VERSION } from "./types.mjs";
+/** Stable identifier for the published contract, versioned by the tag. */
+export const CHART_RULE_SCHEMA_ID = `https://rippling.com/schemas/${CHART_RULE_CONTRACT_VERSION}.json`;
+/**
+ * JSON Schema (2020-12) for the `{$rule}` placeholder and its closed node set.
+ *
+ * This is the contract. A consumer that keeps its own rule evaluator (rather
+ * than importing `evaluate`) can validate against this so the two never drift —
+ * every kind and operand shape the builders can emit is described here.
+ */
+export const chartRuleSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: CHART_RULE_SCHEMA_ID,
+    title: 'Chart rule placeholder',
+    description: 'A rule tree the chart agent emits into a chart option, marked with $rule.',
+    type: 'object',
+    required: ['$rule', 'channel'],
+    additionalProperties: false,
+    properties: {
+        // A colour rule's top-level tree is the conditional-value form (`when(...)`),
+        // matching what `color()` builds and accepts. A bare ref/comparison/literal
+        // resolves to a number/boolean/constant, not a colour decision.
+        $rule: { $ref: '#/$defs/ifElse' },
+        channel: { const: 'color' },
+    },
+    $defs: {
+        scalar: { type: ['number', 'string', 'boolean', 'null'] },
+        node: {
+            oneOf: [
+                { $ref: '#/$defs/ref' },
+                { $ref: '#/$defs/literal' },
+                { $ref: '#/$defs/comparison' },
+                { $ref: '#/$defs/ifElse' },
+            ],
+        },
+        ref: {
+            type: 'object',
+            required: ['kind'],
+            additionalProperties: false,
+            properties: { kind: { const: 'value' } },
+        },
+        literal: {
+            type: 'object',
+            required: ['kind', 'value'],
+            additionalProperties: false,
+            properties: { kind: { const: 'literal' }, value: { $ref: '#/$defs/scalar' } },
+        },
+        comparison: {
+            type: 'object',
+            required: ['kind', 'left', 'right'],
+            additionalProperties: false,
+            properties: {
+                kind: { enum: ['equals', 'isNot', 'lessThan', 'greaterThan', 'lessOrEqual', 'greaterOrEqual'] },
+                left: { $ref: '#/$defs/node' },
+                right: { $ref: '#/$defs/node' },
+            },
+        },
+        ifElse: {
+            type: 'object',
+            required: ['kind', 'cond', 'then', 'else'],
+            additionalProperties: false,
+            properties: {
+                kind: { const: 'ifElse' },
+                cond: { $ref: '#/$defs/node' },
+                then: { $ref: '#/$defs/node' },
+                else: { $ref: '#/$defs/node' },
+            },
+        },
+    },
+};
+//# sourceMappingURL=schema.mjs.map

package/lib/charts/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","sourceRoot":"","sources":["../../src/lib/charts/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,oBAAgB;AAEtD,0EAA0E;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,gCAAgC,2BAA2B,OAAO,CAAC;AAEvG;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,OAAO,EAAE,8CAA8C;IACvD,GAAG,EAAE,oBAAoB;IACzB,KAAK,EAAE,wBAAwB;IAC/B,WAAW,EAAE,2EAA2E;IACxF,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC;IAC9B,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,8EAA8E;QAC9E,4EAA4E;QAC5E,gEAAgE;QAChE,KAAK,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;QACjC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE;KAC5B;IACD,KAAK,EAAE;QACL,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE;QACzD,IAAI,EAAE;YACJ,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,aAAa,EAAE;gBACvB,EAAE,IAAI,EAAE,iBAAiB,EAAE;gBAC3B,EAAE,IAAI,EAAE,oBAAoB,EAAE;gBAC9B,EAAE,IAAI,EAAE,gBAAgB,EAAE;aAC3B;SACF;QACD,GAAG,EAAE;YACH,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,CAAC;YAClB,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;SACzC;QACD,OAAO,EAAE;YACP,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;YAC3B,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE;SAC9E;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;YACnC,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE;gBACV,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,CAAC,EAAE;gBAC/F,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,KAAK,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;aAChC;SACF;QACD,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAC1C,oBAAoB,EAAE,KAAK;YAC3B,UAAU,EAAE;gBACV,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;gBACzB,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;gBAC9B,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;aAC/B;SACF;KACF;CACO,CAAC"}

package/lib/charts/types.d.mts

@@ -0,0 +1,79 @@
+/**
+ * Chart rule vocabulary — shared types.
+ *
+ * A rule is a small, serializable tree of nodes discriminated by `kind`. The
+ * agent builds it with the helpers in `builders.ts`, which emit it wrapped in a
+ * `{$rule}` placeholder — the same idea as the `{$fn}` placeholders a chart
+ * already emits. The renderer resolves it with `evaluate`; the settings panel
+ * reads it with `describe`. All three agree because a node can only ever be one
+ * of the kinds defined here — the closed set the `chartRuleSchema` describes.
+ *
+ * v1 is scoped to conditional formatting: compare this datum's `value` against a
+ * constant, and (optionally) pick between two values. Richer pieces — aggregates,
+ * logic, more refs — are the documented roadmap in the README.
+ */
+export declare const CHART_RULE_CONTRACT_VERSION: "chart_rule.v1";
+export type ChartRuleContractVersion = typeof CHART_RULE_CONTRACT_VERSION;
+/** A leaf value a rule can carry or resolve to. */
+export type Scalar = number | string | boolean | null;
+/** Reads a value out of the evaluation context — this datum's plotted value. */
+export type RefNode = {
+    kind: 'value';
+};
+export interface LiteralNode {
+    kind: 'literal';
+    value: Scalar;
+}
+export type ComparisonKind = 'equals' | 'isNot' | 'lessThan' | 'greaterThan' | 'lessOrEqual' | 'greaterOrEqual';
+export interface ComparisonNode {
+    kind: ComparisonKind;
+    left: RuleNode;
+    right: RuleNode;
+}
+/** The conditional-value form produced by `when(cond, then, else)`. */
+export interface IfElseNode {
+    kind: 'ifElse';
+    cond: RuleNode;
+    then: RuleNode;
+    else: RuleNode;
+}
+/** Any node of a rule tree. */
+export type RuleNode = RefNode | LiteralNode | ComparisonNode | IfElseNode;
+/**
+ * The chart channel a rule drives. v1 supports colour only — a rule decides the
+ * colour of a series/datum. Other channels (opacity, label visibility, …) are
+ * the documented roadmap and would be added here.
+ */
+export type RuleChannel = 'color';
+/**
+ * What a builder returns: a rule tree, marked so the renderer can find it, and
+ * tagged with the channel it targets. `channel: 'color'` says this resolves to a
+ * colour — so a reader sees the target without inferring it from where it sits.
+ */
+export interface RulePlaceholder {
+    $rule: RuleNode;
+    channel: RuleChannel;
+}
+/** A placeholder, or the bare tree — what `evaluate` and `describe` accept. */
+export type Rule = RulePlaceholder | RuleNode;
+/** What a rule is evaluated against: the current datum's value. */
+export interface RuleContext {
+    value: number;
+}
+/** The result of evaluating a node. */
+export type RuleValue = Scalar;
+/**
+ * The deepest a rule may nest before `evaluate`/`describe` refuse it. Real rules
+ * are a handful of levels; this only stops a pathological deserialized tree from
+ * overflowing the stack. Far below the JS call-stack limit.
+ */
+export declare const MAX_RULE_DEPTH = 256;
+export type ControlRole = 'rule' | 'comparison' | 'ref' | 'literal';
+/** A node as the panel should show it: a label, its editable value, its parts. */
+export interface Control {
+    role: ControlRole;
+    label: string;
+    value?: Scalar;
+    parts?: Control[];
+}
+//# sourceMappingURL=types.d.mts.map

package/lib/charts/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../src/lib/charts/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,2BAA2B,EAAG,eAAwB,CAAC;AACpE,MAAM,MAAM,wBAAwB,GAAG,OAAO,2BAA2B,CAAC;AAE1E,mDAAmD;AACnD,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAMtD,gFAAgF;AAChF,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAExC,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,OAAO,GACP,UAAU,GACV,aAAa,GACb,aAAa,GACb,gBAAgB,CAAC;AACrB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,+BAA+B;AAC/B,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,GAAG,UAAU,CAAC;AAM3E;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;CACtB;AAED,+EAA+E;AAC/E,MAAM,MAAM,IAAI,GAAG,eAAe,GAAG,QAAQ,CAAC;AAM9C,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,uCAAuC;AACvC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAMlC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AAEpE,kFAAkF;AAClF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB"}

package/lib/charts/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Chart rule vocabulary — shared types.
+ *
+ * A rule is a small, serializable tree of nodes discriminated by `kind`. The
+ * agent builds it with the helpers in `builders.ts`, which emit it wrapped in a
+ * `{$rule}` placeholder — the same idea as the `{$fn}` placeholders a chart
+ * already emits. The renderer resolves it with `evaluate`; the settings panel
+ * reads it with `describe`. All three agree because a node can only ever be one
+ * of the kinds defined here — the closed set the `chartRuleSchema` describes.
+ *
+ * v1 is scoped to conditional formatting: compare this datum's `value` against a
+ * constant, and (optionally) pick between two values. Richer pieces — aggregates,
+ * logic, more refs — are the documented roadmap in the README.
+ */
+export declare const CHART_RULE_CONTRACT_VERSION: "chart_rule.v1";
+export type ChartRuleContractVersion = typeof CHART_RULE_CONTRACT_VERSION;
+/** A leaf value a rule can carry or resolve to. */
+export type Scalar = number | string | boolean | null;
+/** Reads a value out of the evaluation context — this datum's plotted value. */
+export type RefNode = {
+    kind: 'value';
+};
+export interface LiteralNode {
+    kind: 'literal';
+    value: Scalar;
+}
+export type ComparisonKind = 'equals' | 'isNot' | 'lessThan' | 'greaterThan' | 'lessOrEqual' | 'greaterOrEqual';
+export interface ComparisonNode {
+    kind: ComparisonKind;
+    left: RuleNode;
+    right: RuleNode;
+}
+/** The conditional-value form produced by `when(cond, then, else)`. */
+export interface IfElseNode {
+    kind: 'ifElse';
+    cond: RuleNode;
+    then: RuleNode;
+    else: RuleNode;
+}
+/** Any node of a rule tree. */
+export type RuleNode = RefNode | LiteralNode | ComparisonNode | IfElseNode;
+/**
+ * The chart channel a rule drives. v1 supports colour only — a rule decides the
+ * colour of a series/datum. Other channels (opacity, label visibility, …) are
+ * the documented roadmap and would be added here.
+ */
+export type RuleChannel = 'color';
+/**
+ * What a builder returns: a rule tree, marked so the renderer can find it, and
+ * tagged with the channel it targets. `channel: 'color'` says this resolves to a
+ * colour — so a reader sees the target without inferring it from where it sits.
+ */
+export interface RulePlaceholder {
+    $rule: RuleNode;
+    channel: RuleChannel;
+}
+/** A placeholder, or the bare tree — what `evaluate` and `describe` accept. */
+export type Rule = RulePlaceholder | RuleNode;
+/** What a rule is evaluated against: the current datum's value. */
+export interface RuleContext {
+    value: number;
+}
+/** The result of evaluating a node. */
+export type RuleValue = Scalar;
+/**
+ * The deepest a rule may nest before `evaluate`/`describe` refuse it. Real rules
+ * are a handful of levels; this only stops a pathological deserialized tree from
+ * overflowing the stack. Far below the JS call-stack limit.
+ */
+export declare const MAX_RULE_DEPTH = 256;
+export type ControlRole = 'rule' | 'comparison' | 'ref' | 'literal';
+/** A node as the panel should show it: a label, its editable value, its parts. */
+export interface Control {
+    role: ControlRole;
+    label: string;
+    value?: Scalar;
+    parts?: Control[];
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/charts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/charts/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,2BAA2B,EAAG,eAAwB,CAAC;AACpE,MAAM,MAAM,wBAAwB,GAAG,OAAO,2BAA2B,CAAC;AAE1E,mDAAmD;AACnD,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAMtD,gFAAgF;AAChF,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAExC,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,OAAO,GACP,UAAU,GACV,aAAa,GACb,aAAa,GACb,gBAAgB,CAAC;AACrB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,+BAA+B;AAC/B,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,GAAG,UAAU,CAAC;AAM3E;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;CACtB;AAED,+EAA+E;AAC/E,MAAM,MAAM,IAAI,GAAG,eAAe,GAAG,QAAQ,CAAC;AAM9C,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,uCAAuC;AACvC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAMlC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AAEpE,kFAAkF;AAClF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB"}

package/lib/charts/types.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Chart rule vocabulary — shared types.
+ *
+ * A rule is a small, serializable tree of nodes discriminated by `kind`. The
+ * agent builds it with the helpers in `builders.ts`, which emit it wrapped in a
+ * `{$rule}` placeholder — the same idea as the `{$fn}` placeholders a chart
+ * already emits. The renderer resolves it with `evaluate`; the settings panel
+ * reads it with `describe`. All three agree because a node can only ever be one
+ * of the kinds defined here — the closed set the `chartRuleSchema` describes.
+ *
+ * v1 is scoped to conditional formatting: compare this datum's `value` against a
+ * constant, and (optionally) pick between two values. Richer pieces — aggregates,
+ * logic, more refs — are the documented roadmap in the README.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RULE_DEPTH = exports.CHART_RULE_CONTRACT_VERSION = void 0;
+exports.CHART_RULE_CONTRACT_VERSION = 'chart_rule.v1';
+/**
+ * The deepest a rule may nest before `evaluate`/`describe` refuse it. Real rules
+ * are a handful of levels; this only stops a pathological deserialized tree from
+ * overflowing the stack. Far below the JS call-stack limit.
+ */
+exports.MAX_RULE_DEPTH = 256;
+//# sourceMappingURL=types.js.map

package/lib/charts/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/lib/charts/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEU,QAAA,2BAA2B,GAAG,eAAwB,CAAC;AA8EpE;;;;GAIG;AACU,QAAA,cAAc,GAAG,GAAG,CAAC"}