@cxpinsight/survey-spec 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# @cxpinsight/survey-spec
+
+Behaviour that must be identical for a respondent regardless of how they arrived
+— a link, a site running the web SDK, or a mobile app.
+
+Three renderers implemented this independently, and drift was not hypothetical:
+
+- the React tokenizer's check for "did the multi-character operator loop consume
+  something" was `src[i - 1] === src[i]`, which is not that question, so every
+  `showWhen` using `<=`, `>=`, `==`, `<>`, `&&` or `||` silently evaluated false
+  and **hid its question** — on the live respondent path for link surveys, while
+  mobile and web handled all six
+- the web SDK could resolve only the `device` namespace, and only because it
+  faked it by concatenating `'device.'` onto a key, so `{{user.plan}}` and every
+  other namespace evaluated false there and true elsewhere
+- an unparseable expression hid the question on two renderers and showed it on
+  the third
+
+## Current scope
+
+Expression evaluation: `evaluateExpression`, `evaluateCondition`, `isParseable`.
+
+Page flow, validation, interpolation and the question-type registry are the
+remaining candidates — all of them currently duplicated across the three
+renderers.
+
+## Who consumes it
+
+| | |
+| --- | --- |
+| React renderer | imports this package; its `renderer/lib/expressionEval.ts` is now a re-export |
+| Mobile SDK | still its own copy — migration pending |
+| Web SDK | still its own copy, inline in `survey.js` — no module system, so it needs a generated ES5 build |
+
+`tools/survey-conformance` runs identical fixtures through the spec and every
+renderer and **fails on any disagreement**, so the two remaining copies cannot
+drift while they are being migrated.
+
+## Decisions encoded here
+
+**An unparseable condition is ignored, not false.** A hidden question is
+invisible in the response data — no answers, no error, no signal — so a typo used
+to cause silent data loss. It now shows, and the builder flags the expression
+using this package's own `isParseable`, so the warning and the runtime behaviour
+cannot disagree.
+
+**Namespaces are nested objects.** `variables.device.theme`, not
+`variables['device.theme']`. That is what lets an SDK expose structured runtime
+signals without the grammar growing new token kinds.
+
+## Linking
+
+This repo has no npm workspaces and no `file:` dependencies, so the frontend
+resolves the package through a tsconfig path and a matching Vite alias rather
+than an install. Introducing workspaces would change resolution for every other
+package here, which is a bigger decision than this extraction.

package/dist/expressionEval.d.ts

@@ -0,0 +1,7 @@
+export type { AnswersMap, VariablesMap, EvalContext } from './types';
+import type { EvalContext } from './types';
+export declare function evaluateExpression(source: string, ctx: EvalContext): unknown;
+export declare function evaluateCondition(source: string | undefined, ctx: EvalContext): boolean;
+/** Whether `source` parses at all, independent of what it evaluates to. */
+export declare function isParseable(source: string | undefined): boolean;
+//# sourceMappingURL=expressionEval.d.ts.map

package/dist/expressionEval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionEval.d.ts","sourceRoot":"","sources":["../src/expressionEval.ts"],"names":[],"mappings":"AAwBA,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAY5E;AAID,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAcvF;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAS/D"}

package/dist/expressionEval.js

@@ -0,0 +1,336 @@
+"use strict";
+// Expression evaluator — supports the subset of operators the spec
+// commits to (spec §7, §22):
+//
+//   Comparators:  =  !=  <  >  <=  >=
+//   Boolean:      and  or  not  &&  ||  !
+//   Arithmetic:   +  -  *  /
+//   Refs:         {q_id}          the respondent's answer to q_id
+//                 {{variable}}    resolved variable value
+//                 'string'        string literal
+//                 42              numeric literal
+//                 true / false    boolean literal
+//
+// This is deliberately a simple tokens-based evaluator, not a full
+// JS-compatible expression engine. It's used for:
+//   - showWhen / enabledWhen / requiredWhen (question + section)
+//   - `expression` type questions (computed value)
+//   - `calculated` variable expressions
+//
+// Being cautious: an untyped eval() would let survey authors run
+// arbitrary JS against respondent answers. This restricted grammar
+// keeps the surface area bounded.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = evaluateExpression;
+exports.evaluateCondition = evaluateCondition;
+exports.isParseable = isParseable;
+// ─── Public entry point ───────────────────────────────────────────────
+function evaluateExpression(source, ctx) {
+    if (typeof source !== 'string')
+        return undefined;
+    const src = source.trim();
+    if (!src)
+        return undefined;
+    try {
+        const tokens = tokenize(src);
+        const [value, consumed] = parseExpression(tokens, 0, ctx);
+        if (consumed !== tokens.length)
+            return undefined; // trailing garbage
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+// showWhen/enabledWhen coerce the result to boolean. Empty / undefined
+// evaluates to false (hides the question) — friendlier than throwing.
+function evaluateCondition(source, ctx) {
+    if (!source)
+        return true; // no condition = always shown
+    // An expression that cannot be PARSED is not a false condition — it is not a
+    // condition. Treating a typo as "false" hid the question, and a hidden question
+    // is invisible in the response data: no answers, no error, no signal, and the
+    // author concludes nobody wanted to answer it. Silent data loss is the worse
+    // failure, so an invalid condition is ignored and the question shows. The
+    // builder is where a malformed expression should be surfaced, before it ships.
+    //
+    // A well-formed expression that evaluates falsy still hides the question, which
+    // is the whole point of showWhen. Only unparseable input is ignored.
+    if (!isParseable(source))
+        return true;
+    const result = evaluateExpression(source, ctx);
+    return truthy(result);
+}
+/** Whether `source` parses at all, independent of what it evaluates to. */
+function isParseable(source) {
+    if (!source || !source.trim())
+        return true;
+    try {
+        const tokens = tokenize(source.trim());
+        const [, consumed] = parseExpression(tokens, 0, { variables: {}, answers: {} });
+        return consumed === tokens.length;
+    }
+    catch {
+        return false;
+    }
+}
+function tokenize(src) {
+    const tokens = [];
+    let i = 0;
+    const len = src.length;
+    while (i < len) {
+        const c = src[i];
+        // whitespace
+        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+            i++;
+            continue;
+        }
+        // string literal — single or double quoted
+        if (c === "'" || c === '"') {
+            const quote = c;
+            let out = '';
+            i++;
+            while (i < len && src[i] !== quote) {
+                if (src[i] === '\\' && i + 1 < len) {
+                    out += src[i + 1];
+                    i += 2;
+                }
+                else {
+                    out += src[i];
+                    i++;
+                }
+            }
+            i++; // closing quote
+            tokens.push({ kind: 'str', value: out });
+            continue;
+        }
+        // numeric literal
+        if ((c >= '0' && c <= '9') || (c === '-' && src[i + 1] >= '0' && src[i + 1] <= '9' && !prevExpectsBinary(tokens))) {
+            let j = i;
+            if (src[j] === '-')
+                j++;
+            while (j < len && ((src[j] >= '0' && src[j] <= '9') || src[j] === '.'))
+                j++;
+            tokens.push({ kind: 'num', value: parseFloat(src.slice(i, j)) });
+            i = j;
+            continue;
+        }
+        // {{variable_ref}} — spec §22 interpolation shape
+        if (c === '{' && src[i + 1] === '{') {
+            const end = src.indexOf('}}', i + 2);
+            if (end < 0)
+                throw new Error('unterminated {{');
+            const inner = src.slice(i + 2, end).trim();
+            const dot = inner.indexOf('.');
+            if (dot > 0) {
+                tokens.push({ kind: 'variable_ref', name: inner.slice(0, dot).trim(), suffix: inner.slice(dot + 1).trim() });
+            }
+            else {
+                tokens.push({ kind: 'variable_ref', name: inner });
+            }
+            i = end + 2;
+            continue;
+        }
+        // {q_id} — answer reference (single-brace, spec §7)
+        if (c === '{') {
+            const end = src.indexOf('}', i + 1);
+            if (end < 0)
+                throw new Error('unterminated {');
+            tokens.push({ kind: 'answer_ref', name: src.slice(i + 1, end).trim() });
+            i = end + 1;
+            continue;
+        }
+        // parentheses
+        if (c === '(') {
+            tokens.push({ kind: 'lparen' });
+            i++;
+            continue;
+        }
+        if (c === ')') {
+            tokens.push({ kind: 'rparen' });
+            i++;
+            continue;
+        }
+        // Multi-character operators. Order matters — longest first.
+        //
+        // The "did we consume one?" check used to be `src[i - 1] === src[i]`, which
+        // is not that question. After `<=` is consumed, `c` still holds `<` from the
+        // top of the loop, so the single-character branch below pushed a SECOND `<`
+        // token and advanced i again. The extra token made `consumed !== tokens.length`
+        // in evaluateExpression, which returns undefined, which is falsy — so every
+        // showWhen using <=, >=, ==, <> , && or || silently evaluated to FALSE and hid
+        // its question. Only `!=` survived, by accident of token ordering.
+        //
+        // This is the live respondent path for link surveys and SdkSurveyHost, while
+        // the mobile and web SDKs both tokenize correctly — so the same survey branched
+        // differently depending on how a respondent arrived. Mobile already carries
+        // this fix (survey/expressionEval.ts); this is that fix, ported back.
+        let matchedMulti = false;
+        for (const op of ['<=', '>=', '!=', '<>', '&&', '||', '==']) {
+            if (src.slice(i, i + op.length) === op) {
+                tokens.push({ kind: 'op', value: op === '==' ? '=' : op });
+                i += op.length;
+                matchedMulti = true;
+                break;
+            }
+        }
+        if (matchedMulti)
+            continue;
+        // Single-char operators
+        if ('=<>+-*/!'.includes(c)) {
+            tokens.push({ kind: 'op', value: c });
+            i++;
+            continue;
+        }
+        // Keywords: true / false / null / and / or / not / contains
+        const kw = src.slice(i).match(/^[a-zA-Z_][a-zA-Z_0-9]*/);
+        if (kw) {
+            const word = kw[0];
+            i += word.length;
+            const lower = word.toLowerCase();
+            if (lower === 'true')
+                tokens.push({ kind: 'bool', value: true });
+            else if (lower === 'false')
+                tokens.push({ kind: 'bool', value: false });
+            else if (lower === 'null')
+                tokens.push({ kind: 'null' });
+            else if (lower === 'and')
+                tokens.push({ kind: 'op', value: '&&' });
+            else if (lower === 'or')
+                tokens.push({ kind: 'op', value: '||' });
+            else if (lower === 'not')
+                tokens.push({ kind: 'op', value: '!' });
+            else if (lower === 'contains')
+                tokens.push({ kind: 'op', value: 'contains' });
+            else
+                throw new Error(`unknown identifier "${word}" — refs must be wrapped in {}`);
+            continue;
+        }
+        throw new Error(`unexpected character "${c}" at position ${i}`);
+    }
+    return tokens;
+}
+function prevExpectsBinary(tokens) {
+    const prev = tokens[tokens.length - 1];
+    if (!prev)
+        return false;
+    return prev.kind === 'num' || prev.kind === 'str' || prev.kind === 'bool'
+        || prev.kind === 'answer_ref' || prev.kind === 'variable_ref'
+        || prev.kind === 'rparen';
+}
+// ─── Parser — precedence climbing ────────────────────────────────────
+// Operator precedence table — higher number = tighter binding.
+const PREC = {
+    '||': 1, '&&': 2,
+    '=': 3, '!=': 3, '<>': 3, 'contains': 3,
+    '<': 4, '>': 4, '<=': 4, '>=': 4,
+    '+': 5, '-': 5,
+    '*': 6, '/': 6,
+};
+function parseExpression(tokens, pos, ctx, minPrec = 1) {
+    let [lhs, next] = parseUnary(tokens, pos, ctx);
+    while (next < tokens.length) {
+        const t = tokens[next];
+        if (t.kind !== 'op')
+            break;
+        const prec = PREC[t.value];
+        if (prec === undefined || prec < minPrec)
+            break;
+        const op = t.value;
+        const [rhs, after] = parseExpression(tokens, next + 1, ctx, prec + 1);
+        lhs = applyBinary(op, lhs, rhs);
+        next = after;
+    }
+    return [lhs, next];
+}
+function parseUnary(tokens, pos, ctx) {
+    const t = tokens[pos];
+    if (!t)
+        throw new Error('unexpected end of expression');
+    if (t.kind === 'op' && t.value === '!') {
+        const [inner, after] = parseUnary(tokens, pos + 1, ctx);
+        return [!truthy(inner), after];
+    }
+    if (t.kind === 'op' && t.value === '-') {
+        const [inner, after] = parseUnary(tokens, pos + 1, ctx);
+        return [-Number(inner), after];
+    }
+    return parsePrimary(tokens, pos, ctx);
+}
+function parsePrimary(tokens, pos, ctx) {
+    const t = tokens[pos];
+    if (!t)
+        throw new Error('unexpected end of expression');
+    switch (t.kind) {
+        case 'num': return [t.value, pos + 1];
+        case 'str': return [t.value, pos + 1];
+        case 'bool': return [t.value, pos + 1];
+        case 'null': return [null, pos + 1];
+        case 'answer_ref': return [ctx.answers[t.name], pos + 1];
+        case 'variable_ref': {
+            // Resolution rules for {{name.suffix}}:
+            //   • {{q1.answer}}       → ctx.answers.q1 (special-case for legacy)
+            //   • {{customer_name}}   → ctx.variables.customer_name
+            //   • {{device.theme}}    → walk dotted path into ctx.variables.device
+            //   • {{a.b.c.d}}         → walk into ctx.variables.a.b.c.d
+            // A dotted suffix that hits a non-object mid-walk returns undefined —
+            // which then compares falsy in showWhen. This lets authors reference
+            // any structured runtime signal (device, session, session.location, …)
+            // without adding new token kinds — they just live under variables.*
+            // as nested objects, injected by the SDK at render time.
+            if (t.suffix === 'answer')
+                return [ctx.answers[t.name], pos + 1];
+            const root = ctx.variables[t.name];
+            if (!t.suffix)
+                return [root, pos + 1];
+            let cursor = root;
+            for (const seg of t.suffix.split('.')) {
+                if (cursor == null || typeof cursor !== 'object') {
+                    cursor = undefined;
+                    break;
+                }
+                cursor = cursor[seg];
+            }
+            return [cursor, pos + 1];
+        }
+        case 'lparen': {
+            const [inner, after] = parseExpression(tokens, pos + 1, ctx, 1);
+            if (tokens[after]?.kind !== 'rparen')
+                throw new Error('missing closing paren');
+            return [inner, after + 1];
+        }
+        default: throw new Error(`unexpected token: ${JSON.stringify(t)}`);
+    }
+}
+// ─── Operators ───────────────────────────────────────────────────────
+function applyBinary(op, lhs, rhs) {
+    switch (op) {
+        case '=': return String(lhs) === String(rhs);
+        case '!=':
+        case '<>': return String(lhs) !== String(rhs);
+        case '<': return Number(lhs) < Number(rhs);
+        case '>': return Number(lhs) > Number(rhs);
+        case '<=': return Number(lhs) <= Number(rhs);
+        case '>=': return Number(lhs) >= Number(rhs);
+        case '&&': return truthy(lhs) && truthy(rhs);
+        case '||': return truthy(lhs) || truthy(rhs);
+        case '+': return typeof lhs === 'string' || typeof rhs === 'string'
+            ? String(lhs) + String(rhs)
+            : Number(lhs) + Number(rhs);
+        case '-': return Number(lhs) - Number(rhs);
+        case '*': return Number(lhs) * Number(rhs);
+        case '/': return Number(lhs) / Number(rhs);
+        case 'contains':
+            if (Array.isArray(lhs))
+                return lhs.includes(rhs);
+            return String(lhs ?? '').includes(String(rhs));
+        default: return undefined;
+    }
+}
+function truthy(v) {
+    if (v === false || v === null || v === undefined || v === 0 || v === '')
+        return false;
+    if (Array.isArray(v))
+        return v.length > 0;
+    return true;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @cxpinsight/survey-spec
+ *
+ * Behaviour that must be identical for a respondent regardless of how they
+ * arrived — a link, a site running the web SDK, or a mobile app. Three renderers
+ * implemented this separately and drifted: the React tokenizer silently hid every
+ * question whose condition used `<=`, `>=`, `==`, `<>`, `&&` or `||`, and the web
+ * SDK could not resolve any variable namespace except `device`.
+ *
+ * tools/survey-conformance runs the same fixtures through every renderer and
+ * fails on any disagreement.
+ */
+export { evaluateExpression, evaluateCondition, isParseable } from './expressionEval';
+export { resolveVariable } from './resolveVariable';
+export type { AnswersMap, VariablesMap, EvalContext } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVariable = exports.isParseable = exports.evaluateCondition = exports.evaluateExpression = void 0;
+/**
+ * @cxpinsight/survey-spec
+ *
+ * Behaviour that must be identical for a respondent regardless of how they
+ * arrived — a link, a site running the web SDK, or a mobile app. Three renderers
+ * implemented this separately and drifted: the React tokenizer silently hid every
+ * question whose condition used `<=`, `>=`, `==`, `<>`, `&&` or `||`, and the web
+ * SDK could not resolve any variable namespace except `device`.
+ *
+ * tools/survey-conformance runs the same fixtures through every renderer and
+ * fails on any disagreement.
+ */
+var expressionEval_1 = require("./expressionEval");
+Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return expressionEval_1.evaluateExpression; } });
+Object.defineProperty(exports, "evaluateCondition", { enumerable: true, get: function () { return expressionEval_1.evaluateCondition; } });
+Object.defineProperty(exports, "isParseable", { enumerable: true, get: function () { return expressionEval_1.isParseable; } });
+var resolveVariable_1 = require("./resolveVariable");
+Object.defineProperty(exports, "resolveVariable", { enumerable: true, get: function () { return resolveVariable_1.resolveVariable; } });

package/dist/resolveVariable.d.ts

@@ -0,0 +1,19 @@
+/**
+ * One rule for resolving `{{name}}` and `{{name.path}}` against the variable bag.
+ *
+ * It exists because the same reference meant two different things depending on
+ * where it appeared. Conditions walked nested namespaces; text interpolation
+ * looked up a flat dotted key and, when that missed, returned the NAMESPACE
+ * OBJECT — so a nested bag rendered
+ *
+ *   "Hi {{user.name}}"  →  Hi {"plan":"pro","name":"Sam","email":"…"}
+ *
+ * putting every field of that namespace on screen in front of the respondent.
+ * An author has no reason to expect two resolution rules for one syntax, so
+ * there is now one, and both callers use it.
+ *
+ * Flat key first, then walk: a bag built the old way keeps resolving unchanged,
+ * and a nested bag resolves properly.
+ */
+export declare function resolveVariable(variables: Record<string, unknown>, name: string, suffix?: string): unknown;
+//# sourceMappingURL=resolveVariable.d.ts.map

package/dist/resolveVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveVariable.d.ts","sourceRoot":"","sources":["../src/resolveVariable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CA4BT"}

package/dist/resolveVariable.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVariable = resolveVariable;
+/**
+ * One rule for resolving `{{name}}` and `{{name.path}}` against the variable bag.
+ *
+ * It exists because the same reference meant two different things depending on
+ * where it appeared. Conditions walked nested namespaces; text interpolation
+ * looked up a flat dotted key and, when that missed, returned the NAMESPACE
+ * OBJECT — so a nested bag rendered
+ *
+ *   "Hi {{user.name}}"  →  Hi {"plan":"pro","name":"Sam","email":"…"}
+ *
+ * putting every field of that namespace on screen in front of the respondent.
+ * An author has no reason to expect two resolution rules for one syntax, so
+ * there is now one, and both callers use it.
+ *
+ * Flat key first, then walk: a bag built the old way keeps resolving unchanged,
+ * and a nested bag resolves properly.
+ */
+function resolveVariable(variables, name, suffix) {
+    if (!variables)
+        return undefined;
+    const full = suffix ? `${name}.${suffix}` : name;
+    let value;
+    if (Object.prototype.hasOwnProperty.call(variables, full)) {
+        // 1. Exact flat key — what bags built before namespaces contained.
+        value = variables[full];
+    }
+    else {
+        // 2. Walk the dotted path into nested namespaces.
+        const segments = full.split('.');
+        let cursor = variables;
+        for (const seg of segments) {
+            if (cursor == null || typeof cursor !== 'object') {
+                cursor = undefined;
+                break;
+            }
+            cursor = cursor[seg];
+        }
+        value = cursor;
+    }
+    // 3. A namespace is not a value. `{{user}}` with no path resolves to the whole
+    //    object, and stringifying it puts every field of that bag — plan, email,
+    //    internal ids — on screen in front of the respondent. Applies to BOTH
+    //    lookup paths: a flat bag can hold an object under a bare key too.
+    //    Arrays are values (a multi-select answer), so they pass.
+    if (value !== null && typeof value === 'object' && !Array.isArray(value))
+        return undefined;
+    return value;
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/** Answers keyed by question id, as the renderer has collected them so far. */
+export type AnswersMap = Record<string, unknown>;
+/**
+ * The variable environment a condition resolves against.
+ *
+ * Namespaces are NESTED objects — `variables.device.theme`, `variables.user.plan`
+ * — which is what lets an SDK expose structured runtime signals without the
+ * expression grammar growing new token kinds. The web SDK used to flatten one
+ * namespace by concatenating `'device.'` onto a key, which meant every OTHER
+ * namespace silently evaluated false there and true elsewhere.
+ */
+export type VariablesMap = Record<string, unknown>;
+export interface EvalContext {
+    variables: VariablesMap;
+    answers: AnswersMap;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,UAAU,CAAC;CACrB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@cxpinsight/survey-spec",
+  "version": "0.1.0",
+  "description": "The survey specification the renderers share — expression evaluation first. Source of truth for behaviour that must be identical on web, links and mobile.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.js",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "devDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SaifDalli2/CX_Platform.git",
+    "directory": "packages/survey-spec"
+  }
+}

package/src/expressionEval.d.ts

@@ -0,0 +1,7 @@
+export type { AnswersMap, VariablesMap, EvalContext } from './types';
+import type { EvalContext } from './types';
+export declare function evaluateExpression(source: string, ctx: EvalContext): unknown;
+export declare function evaluateCondition(source: string | undefined, ctx: EvalContext): boolean;
+/** Whether `source` parses at all, independent of what it evaluates to. */
+export declare function isParseable(source: string | undefined): boolean;
+//# sourceMappingURL=expressionEval.d.ts.map

package/src/expressionEval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionEval.d.ts","sourceRoot":"","sources":["expressionEval.ts"],"names":[],"mappings":"AAwBA,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAY5E;AAID,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAcvF;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAS/D"}