@micha.bigler/survey-renderer 0.1.0

package/dist/stagedGroups.js

@@ -0,0 +1,258 @@
+import { resolveQuestionUiConfig } from "./questionUiConfig";
+function tokenizeAppearance(appearance) {
+    return String(appearance || "")
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter(Boolean);
+}
+function hasStagedGroupAppearance(group) {
+    return tokenizeAppearance(group === null || group === void 0 ? void 0 : group.appearance).includes("staged-group");
+}
+function stripOuterParentheses(expression) {
+    let source = String(expression || "").trim();
+    while (source.startsWith("(") && source.endsWith(")")) {
+        let depth = 0;
+        let balanced = true;
+        let quoteCharacter = "";
+        for (let index = 0; index < source.length; index += 1) {
+            const character = source[index];
+            if (quoteCharacter) {
+                if (character === quoteCharacter && source[index - 1] !== "\\") {
+                    quoteCharacter = "";
+                }
+                continue;
+            }
+            if (character === "'" || character === "\"") {
+                quoteCharacter = character;
+                continue;
+            }
+            if (character === "(") {
+                depth += 1;
+            }
+            else if (character === ")") {
+                depth -= 1;
+            }
+            if (depth === 0 && index < source.length - 1) {
+                balanced = false;
+                break;
+            }
+        }
+        if (!balanced) {
+            return source;
+        }
+        source = source.slice(1, -1).trim();
+    }
+    return source;
+}
+function splitTopLevel(expression, keyword) {
+    const source = stripOuterParentheses(expression);
+    const lowerKeyword = ` ${String(keyword || "").toLowerCase()} `;
+    const parts = [];
+    let current = "";
+    let depth = 0;
+    let quoteCharacter = "";
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (quoteCharacter) {
+            current += character;
+            if (character === quoteCharacter && source[index - 1] !== "\\") {
+                quoteCharacter = "";
+            }
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quoteCharacter = character;
+            current += character;
+            continue;
+        }
+        if (character === "(") {
+            depth += 1;
+            current += character;
+            continue;
+        }
+        if (character === ")") {
+            depth -= 1;
+            current += character;
+            continue;
+        }
+        if (depth === 0) {
+            const nextSlice = source.slice(index, index + lowerKeyword.length).toLowerCase();
+            if (nextSlice === lowerKeyword) {
+                parts.push(current.trim());
+                current = "";
+                index += lowerKeyword.length - 1;
+                continue;
+            }
+        }
+        current += character;
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+function parseLiteral(rawValue) {
+    const source = String(rawValue || "").trim();
+    if (!source) {
+        return "";
+    }
+    if ((source.startsWith("'") && source.endsWith("'")) || (source.startsWith("\"") && source.endsWith("\""))) {
+        return source.slice(1, -1);
+    }
+    if (/^\d+(\.\d+)?$/.test(source)) {
+        return Number(source);
+    }
+    if (/^true\(\)$/i.test(source) || /^true$/i.test(source)) {
+        return true;
+    }
+    if (/^false\(\)$/i.test(source) || /^false$/i.test(source)) {
+        return false;
+    }
+    const fieldMatch = source.match(/^\$\{([^}]+)\}$/);
+    if (fieldMatch) {
+        return { fieldName: fieldMatch[1] };
+    }
+    return source;
+}
+function resolveOperandValue(operand, answers) {
+    if (operand && typeof operand === "object" && operand.fieldName) {
+        return answers === null || answers === void 0 ? void 0 : answers[operand.fieldName];
+    }
+    return operand;
+}
+function selected(value, option) {
+    if (value == null) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => String(entry)).includes(String(option));
+    }
+    return String(value) === String(option);
+}
+function countSelected(value) {
+    if (value == null || value === "") {
+        return 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length;
+    }
+    return 1;
+}
+function compareValues(left, operator, right) {
+    switch (operator) {
+        case "=":
+        case "==":
+            return left === right;
+        case "!=":
+        case "<>":
+            return left !== right;
+        case "<":
+            return left < right;
+        case "<=":
+            return left <= right;
+        case ">":
+            return left > right;
+        case ">=":
+            return left >= right;
+        default:
+            return false;
+    }
+}
+function evaluateAtomicExpression(expression, answers) {
+    const source = stripOuterParentheses(expression);
+    if (!source) {
+        return true;
+    }
+    if (/^true\(\)$/i.test(source) || /^true$/i.test(source)) {
+        return true;
+    }
+    if (/^false\(\)$/i.test(source) || /^false$/i.test(source)) {
+        return false;
+    }
+    // Unterstützt XLSForm-Syntax selected(${field}, 'val') und einfaches selected(field, 'val')
+    const selectedMatch = source.match(/^selected\(\s*(?:\$\{([^}]+)\}|([^,\s)]+))\s*,\s*(['"])(.*?)\3\s*\)$/i);
+    if (selectedMatch) {
+        const fieldName = selectedMatch[1] || selectedMatch[2];
+        return selected(answers === null || answers === void 0 ? void 0 : answers[fieldName], selectedMatch[4]);
+    }
+    const countSelectedMatch = source.match(/^count-selected\(\s*\$\{([^}]+)\}\s*\)\s*(<=|>=|!=|=|==|<|>)\s*(.+)$/i);
+    if (countSelectedMatch) {
+        const left = countSelected(answers === null || answers === void 0 ? void 0 : answers[countSelectedMatch[1]]);
+        const right = resolveOperandValue(parseLiteral(countSelectedMatch[3]), answers);
+        return compareValues(left, countSelectedMatch[2], right);
+    }
+    const fieldComparisonMatch = source.match(/^\$\{([^}]+)\}\s*(<=|>=|!=|=|==|<|>)\s*(.+)$/i);
+    if (fieldComparisonMatch) {
+        const left = answers === null || answers === void 0 ? void 0 : answers[fieldComparisonMatch[1]];
+        const right = resolveOperandValue(parseLiteral(fieldComparisonMatch[3]), answers);
+        return compareValues(left, fieldComparisonMatch[2], right);
+    }
+    const directFieldMatch = source.match(/^\$\{([^}]+)\}$/);
+    if (directFieldMatch) {
+        return Boolean(answers === null || answers === void 0 ? void 0 : answers[directFieldMatch[1]]);
+    }
+    return false;
+}
+export function evaluateRelevantExpression(expression, answers = {}) {
+    const source = stripOuterParentheses(expression);
+    if (!source) {
+        return true;
+    }
+    const orParts = splitTopLevel(source, "or");
+    if (orParts.length > 1) {
+        return orParts.some((part) => evaluateRelevantExpression(part, answers));
+    }
+    const andParts = splitTopLevel(source, "and");
+    if (andParts.length > 1) {
+        return andParts.every((part) => evaluateRelevantExpression(part, answers));
+    }
+    return evaluateAtomicExpression(source, answers);
+}
+export function mergeStagedAnswers(baseAnswers = {}, stagedAnswersByGroup = {}) {
+    return Object.values(stagedAnswersByGroup || {}).reduce((currentAnswers, groupAnswers) => (Object.assign(Object.assign({}, currentAnswers), (groupAnswers || {}))), Object.assign({}, (baseAnswers || {})));
+}
+export function getGroupsByName(definition = {}) {
+    return Object.fromEntries(((definition === null || definition === void 0 ? void 0 : definition.groups) || []).map((group) => [group.name, group]));
+}
+export function getQuestionStagedGroupKey(question, questionUiConfig = {}, groupsByName = {}) {
+    var _a;
+    const configuredGroupKey = ((_a = resolveQuestionUiConfig(question, questionUiConfig)) === null || _a === void 0 ? void 0 : _a.stagedGroup) || "";
+    if (configuredGroupKey) {
+        return configuredGroupKey;
+    }
+    const groupPath = Array.isArray(question === null || question === void 0 ? void 0 : question.group_path) ? question.group_path : [];
+    const matchedGroup = [...groupPath]
+        .reverse()
+        .map((groupName) => groupsByName === null || groupsByName === void 0 ? void 0 : groupsByName[groupName])
+        .find((group) => hasStagedGroupAppearance(group));
+    return (matchedGroup === null || matchedGroup === void 0 ? void 0 : matchedGroup.name) || "";
+}
+export function getPageStagedGroupKey(pageItem, questionUiConfig = {}, groupsByName = {}) {
+    if ((pageItem === null || pageItem === void 0 ? void 0 : pageItem.pageType) !== "section") {
+        return "";
+    }
+    const stagedGroupKeys = Array.from(new Set((pageItem.questions || [])
+        .map((question) => getQuestionStagedGroupKey(question, questionUiConfig, groupsByName))
+        .filter(Boolean)));
+    return stagedGroupKeys.length === 1 ? stagedGroupKeys[0] : "";
+}
+export function getStagedGroupQuestionNames(definition = {}, groupKey = "", questionUiConfig = {}, groupsByName = {}) {
+    if (!groupKey) {
+        return [];
+    }
+    return ((definition === null || definition === void 0 ? void 0 : definition.questions) || [])
+        .filter((question) => getQuestionStagedGroupKey(question, questionUiConfig, groupsByName) === groupKey)
+        .map((question) => question.name);
+}
+export function getStagedQuestionNames(definition = {}, questionUiConfig = {}, groupsByName = {}) {
+    return ((definition === null || definition === void 0 ? void 0 : definition.questions) || [])
+        .filter((question) => Boolean(getQuestionStagedGroupKey(question, questionUiConfig, groupsByName)))
+        .map((question) => question.name);
+}
+export function isQuestionVisible(question, answers, serverVisibleQuestionNames, questionUiConfig = {}, groupsByName = {}) {
+    const stagedGroupKey = getQuestionStagedGroupKey(question, questionUiConfig, groupsByName);
+    if (!stagedGroupKey) {
+        return serverVisibleQuestionNames.has(question.name);
+    }
+    return evaluateRelevantExpression(question === null || question === void 0 ? void 0 : question.relevant, answers);
+}

package/dist/types.js

@@ -0,0 +1,22 @@
+/**
+ * @typedef {Object} SurveyRuntimeAdapter
+ *
+ * Documents the FULL contract a host app implements around this package -- it is NOT a single
+ * prop object consumed by `SurveyRenderer` itself. `SurveyRenderer` is a pure, stateless
+ * component that only ever receives a `mediaUrl` FUNCTION as one of its own flat props (see
+ * `SurveyRenderer.jsx`); it has no `saveDraft`/`submit`/`uploadImage`/`verifyCaptcha` props and
+ * makes no network calls. Those four operations are owned entirely by the HOST'S OWN wrapper
+ * component (e.g. survey_app's `PublicSurveyRuntime.jsx`/`PreviewSurveyRuntime.jsx`, which stay
+ * outside this package) -- the host wires its own API client into an object shaped like this,
+ * then derives the flat props it passes down to `SurveyRenderer` (in particular `mediaUrl:
+ * (mediaId) => adapter.mediaUrl(mediaId)`) and calls `adapter.saveDraft`/`submit`/`uploadImage`/
+ * `verifyCaptcha` itself around the renderer, not through it. This typedef exists purely to
+ * document that expected host-side shape for implementers building a new host integration.
+ *
+ * @property {(answers: object, meta: object) => Promise<{evaluation: object, validation: object}>} saveDraft
+ * @property {(answers: object, meta: object) => Promise<object>} submit
+ * @property {(file: File) => Promise<{mediaId: number}>} uploadImage
+ * @property {(mediaId: number) => string} mediaUrl
+ * @property {(token: string) => Promise<void>} [verifyCaptcha]
+ */
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@micha.bigler/survey-renderer",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "files": ["dist"],
+  "repository": { "type": "git", "url": "https://github.com/bigler-webapps/survey-renderer" },
+  "private": false,
+  "peerDependencies": {
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "@mui/material": "^7.3.11",
+    "@mui/icons-material": "^7.3.11",
+    "react-i18next": "^17.0.8",
+    "i18next": "^26.2.0"
+  },
+  "dependencies": {
+    "leaflet": "^1.9.4",
+    "react-leaflet": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "prepare": "tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/user-event": "^14.6.1",
+    "jsdom": "^29.1.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  }
+}