@zap-wunschlachen/wl-shared-components 1.0.76 → 1.0.78

package/tests/unit/utils/anamnese.spec.ts

@@ -0,0 +1,531 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  ANAMNESE_FORM_NAME,
+  flattenElements,
+  pickLang,
+  normalizeScalar,
+  buildAllChoices,
+  pageAnswerGroupsFor,
+  type FormElement,
+  type FormPage,
+} from '@/utils/anamnese';
+
+describe('anamnese utilities', () => {
+  // ─── ANAMNESE_FORM_NAME ───────────────────────────────────────────
+  describe('ANAMNESE_FORM_NAME', () => {
+    it('exports the correct constant', () => {
+      expect(ANAMNESE_FORM_NAME).toBe('Anamnese');
+    });
+  });
+
+  // ─── flattenElements ──────────────────────────────────────────────
+  describe('flattenElements', () => {
+    it('returns empty array for no input', () => {
+      expect(flattenElements()).toEqual([]);
+      expect(flattenElements([])).toEqual([]);
+    });
+
+    it('returns non-panel elements unchanged', () => {
+      const els: FormElement[] = [
+        { type: 'text', name: 'q1' },
+        { type: 'checkbox', name: 'q2' },
+      ];
+      expect(flattenElements(els)).toEqual(els);
+    });
+
+    it('flattens panel children one level deep', () => {
+      const els: FormElement[] = [
+        {
+          type: 'panel',
+          elements: [
+            { type: 'text', name: 'inner1' },
+            { type: 'text', name: 'inner2' },
+          ],
+        },
+        { type: 'text', name: 'outer' },
+      ];
+      const flat = flattenElements(els);
+      expect(flat).toHaveLength(3);
+      expect(flat.map(e => e.name)).toEqual(['inner1', 'inner2', 'outer']);
+    });
+
+    it('flattens nested panels recursively', () => {
+      const els: FormElement[] = [
+        {
+          type: 'panel',
+          elements: [
+            {
+              type: 'panel',
+              elements: [{ type: 'text', name: 'deep' }],
+            },
+          ],
+        },
+      ];
+      const flat = flattenElements(els);
+      expect(flat).toHaveLength(1);
+      expect(flat[0].name).toBe('deep');
+    });
+
+    it('keeps panel without elements as-is if elements missing', () => {
+      const els: FormElement[] = [{ type: 'panel' }];
+      expect(flattenElements(els)).toEqual([{ type: 'panel' }]);
+    });
+  });
+
+  // ─── pickLang ─────────────────────────────────────────────────────
+  describe('pickLang', () => {
+    it('returns fallback for undefined', () => {
+      expect(pickLang(undefined)).toBe('');
+      expect(pickLang(undefined, 'fb')).toBe('fb');
+    });
+
+    it('returns string value directly', () => {
+      expect(pickLang('hello')).toBe('hello');
+    });
+
+    it('returns the "default" key from a multilingual object', () => {
+      expect(pickLang({ default: 'Hallo', en: 'Hello' })).toBe('Hallo');
+    });
+
+    it('returns first value if no "default" key', () => {
+      expect(pickLang({ en: 'Hello', de: 'Hallo' })).toBe('Hello');
+    });
+
+    it('returns fallback if object values are empty', () => {
+      expect(pickLang({} as any, 'fb')).toBe('fb');
+    });
+  });
+
+  // ─── normalizeScalar ──────────────────────────────────────────────
+  describe('normalizeScalar', () => {
+    it('returns null for null, empty string, empty array', () => {
+      expect(normalizeScalar(null)).toBeNull();
+      expect(normalizeScalar('')).toBeNull();
+      expect(normalizeScalar([])).toBeNull();
+    });
+
+    it('converts boolean true to "Ja"', () => {
+      expect(normalizeScalar(true)).toBe('Ja');
+    });
+
+    it('converts boolean false to "Nein"', () => {
+      expect(normalizeScalar(false)).toBe('Nein');
+    });
+
+    it('detects data:image strings as signature', () => {
+      expect(normalizeScalar('data:image/png;base64,abc')).toBe('Unterschrift vorhanden');
+    });
+
+    it('formats ISO date strings to German locale', () => {
+      const result = normalizeScalar('2024-03-15T10:30:00Z');
+      expect(result).toMatch(/15\.03\.2024/);
+    });
+
+    it('returns plain strings as-is', () => {
+      expect(normalizeScalar('hello')).toBe('hello');
+    });
+
+    it('converts numbers to string', () => {
+      expect(normalizeScalar(42)).toBe('42');
+    });
+
+    it('handles non-ISO date strings as regular strings', () => {
+      expect(normalizeScalar('2024-03-15')).toBe('2024-03-15');
+    });
+  });
+
+  // ─── buildAllChoices ──────────────────────────────────────────────
+  describe('buildAllChoices', () => {
+    it('builds choices from string array', () => {
+      const el: FormElement = {
+        choices: ['A', 'B', 'C'],
+      };
+      const result = buildAllChoices(el, ['B']);
+      expect(result).toHaveLength(3);
+      expect(result[0]).toEqual({ text: 'A', selected: false });
+      expect(result[1]).toEqual({ text: 'B', selected: true });
+      expect(result[2]).toEqual({ text: 'C', selected: false });
+    });
+
+    it('builds choices from Choice objects with wlColor', () => {
+      const el: FormElement = {
+        choices: [
+          { value: 'yes', text: 'Yes', wlColor: 'green' },
+          { value: 'no', text: 'No', wlColor: 'red' },
+        ],
+      };
+      const result = buildAllChoices(el, ['yes']);
+      expect(result[0]).toEqual({ text: 'Yes', color: 'green', selected: true });
+      expect(result[1]).toEqual({ text: 'No', color: 'red', selected: false });
+    });
+
+    it('uses pickLang for multilingual choice text', () => {
+      const el: FormElement = {
+        choices: [
+          { value: 'v1', text: { default: 'Default Text' } },
+        ],
+      };
+      const result = buildAllChoices(el, []);
+      expect(result[0].text).toBe('Default Text');
+    });
+
+    it('falls back to value when text is missing', () => {
+      const el: FormElement = {
+        choices: [{ value: 'myval' }],
+      };
+      const result = buildAllChoices(el, []);
+      expect(result[0].text).toBe('myval');
+    });
+
+    it('adds "other" item when showOtherItem is true', () => {
+      const el: FormElement = {
+        choices: ['A'],
+        showOtherItem: true,
+        otherText: 'Sonstiges',
+      };
+      const result = buildAllChoices(el, ['other'], 'My custom text');
+      expect(result).toHaveLength(2);
+      expect(result[1]).toEqual({
+        text: 'My custom text',
+        selected: true,
+        isOther: true,
+      });
+    });
+
+    it('uses otherText default when other not selected', () => {
+      const el: FormElement = {
+        choices: [],
+        showOtherItem: true,
+        otherText: 'Sonstiges',
+      };
+      const result = buildAllChoices(el, []);
+      expect(result[0].text).toBe('Sonstiges');
+      expect(result[0].selected).toBe(false);
+    });
+
+    it('falls back to "Andere" for other text when not provided', () => {
+      const el: FormElement = {
+        choices: [],
+        showOtherItem: true,
+      };
+      const result = buildAllChoices(el, []);
+      expect(result[0].text).toBe('Andere');
+    });
+
+    it('adds "none" item when showNoneItem is true', () => {
+      const el: FormElement = {
+        choices: ['A'],
+        showNoneItem: true,
+        noneText: 'Nichts',
+      };
+      const result = buildAllChoices(el, ['none']);
+      expect(result).toHaveLength(2);
+      expect(result[1]).toEqual({
+        text: 'Nichts',
+        selected: true,
+        isNone: true,
+      });
+    });
+
+    it('falls back to "Keine" for none text when not provided', () => {
+      const el: FormElement = {
+        choices: [],
+        showNoneItem: true,
+      };
+      const result = buildAllChoices(el, []);
+      expect(result[0].text).toBe('Keine');
+    });
+
+    it('returns empty when no choices and no special items', () => {
+      const result = buildAllChoices({}, []);
+      expect(result).toEqual([]);
+    });
+  });
+
+  // ─── pageAnswerGroupsFor ──────────────────────────────────────────
+  describe('pageAnswerGroupsFor', () => {
+    const makeForm = (pages: FormPage[]) => ({
+      components: { pages },
+    });
+
+    it('returns empty array when item is falsy', () => {
+      const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      expect(pageAnswerGroupsFor(null, makeForm([]))).toEqual([]);
+      spy.mockRestore();
+    });
+
+    it('returns empty array when form has no pages', () => {
+      const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      expect(pageAnswerGroupsFor({}, { components: {} })).toEqual([]);
+      spy.mockRestore();
+    });
+
+    it('handles components as JSON string', () => {
+      const form = {
+        components: JSON.stringify({
+          pages: [
+            {
+              name: 'p1',
+              title: 'Page 1',
+              elements: [{ name: 'q1', title: 'Question 1' }],
+            },
+          ],
+        }),
+      };
+      const item = { q1: 'answer' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result).toHaveLength(1);
+      expect(result[0].title).toBe('Page 1');
+    });
+
+    it('builds answer groups from simple text answers', () => {
+      const form = makeForm([
+        {
+          name: 'page1',
+          title: 'Seite 1',
+          elements: [
+            { name: 'q1', title: 'Frage 1' },
+            { name: 'q2', title: 'Frage 2' },
+          ],
+        },
+      ]);
+      const item = { q1: 'Antwort 1', q2: 'Antwort 2' };
+      const result = pageAnswerGroupsFor(item, form);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].pageKey).toBe('page1');
+      expect(result[0].title).toBe('Seite 1');
+      expect(result[0].answers).toHaveLength(2);
+      expect(result[0].answers[0].value).toBe('Antwort 1');
+      expect(result[0].answers[1].value).toBe('Antwort 2');
+    });
+
+    it('skips elements with no name', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            { title: 'no name' },
+            { name: 'q1', title: 'Q1' },
+          ],
+        },
+      ]);
+      const item = { q1: 'yes' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers).toHaveLength(1);
+    });
+
+    it('skips elements with null/undefined/empty values', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            { name: 'q1', title: 'Q1' },
+            { name: 'q2', title: 'Q2' },
+            { name: 'q3', title: 'Q3' },
+          ],
+        },
+      ]);
+      const item = { q1: null, q2: undefined, q3: '' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result).toHaveLength(0); // page skipped because no answers
+    });
+
+    it('skips pages with no answers', () => {
+      const form = makeForm([
+        {
+          name: 'empty',
+          title: 'Empty',
+          elements: [{ name: 'q1', title: 'Q1' }],
+        },
+        {
+          name: 'filled',
+          title: 'Filled',
+          elements: [{ name: 'q2', title: 'Q2' }],
+        },
+      ]);
+      const item = { q2: 'answer' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result).toHaveLength(1);
+      expect(result[0].pageKey).toBe('filled');
+    });
+
+    it('handles array values with choices', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            {
+              name: 'symptoms',
+              title: 'Symptome',
+              choices: [
+                { value: 'headache', text: 'Kopfschmerzen', wlColor: 'red' },
+                { value: 'fever', text: 'Fieber', wlColor: 'yellow' },
+              ],
+            },
+          ],
+        },
+      ]);
+      const item = { symptoms: ['headache'] };
+      const result = pageAnswerGroupsFor(item, form);
+
+      const answer = result[0].answers[0];
+      expect(answer.value).toBe('Kopfschmerzen');
+      expect(answer.valueListAll).toHaveLength(2);
+      expect(answer.valueListSelected).toHaveLength(1);
+      expect(answer.hasColor).toBe(true);
+    });
+
+    it('handles string values with choices (single select)', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            {
+              name: 'q1',
+              title: 'Q1',
+              choices: ['Yes', 'No'],
+            },
+          ],
+        },
+      ]);
+      const item = { q1: 'Yes' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers[0].value).toBe('Yes');
+      expect(result[0].answers[0].valueListSelected).toHaveLength(1);
+    });
+
+    it('handles boolean values via normalizeScalar', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [{ name: 'q1', title: 'Q1' }],
+        },
+      ]);
+      const item = { q1: true };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers[0].value).toBe('Ja');
+    });
+
+    it('handles signature pad elements', () => {
+      const getSignatureUrl = (id: string) => `https://example.com/sig/${id}`;
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [{ name: 'sig', title: 'Unterschrift', type: 'signaturepad' }],
+        },
+      ]);
+      const item = { sig: 'sig-123' };
+      const result = pageAnswerGroupsFor(item, form, { getSignatureUrl });
+
+      const answer = result[0].answers[0];
+      expect(answer.isSignature).toBe(true);
+      expect(answer.signatureId).toBe('sig-123');
+      expect(answer.signatureUrl).toBe('https://example.com/sig/sig-123');
+    });
+
+    it('handles signature_pad type alias', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [{ name: 'sig', title: 'Sig', type: 'signature_pad' }],
+        },
+      ]);
+      const item = { sig: 'id-456' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers[0].isSignature).toBe(true);
+      expect(result[0].answers[0].signatureUrl).toBe('');
+    });
+
+    it('reads from answers_json when present', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [{ name: 'q1', title: 'Q1' }],
+        },
+      ]);
+      const item = { answers_json: { q1: 'from json' } };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers[0].value).toBe('from json');
+    });
+
+    it('flattens panel elements within pages', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            {
+              type: 'panel',
+              elements: [{ name: 'q1', title: 'Q1' }],
+            },
+          ],
+        },
+      ]);
+      const item = { q1: 'answer' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].answers).toHaveLength(1);
+      expect(result[0].answers[0].value).toBe('answer');
+    });
+
+    it('generates fallback page title and key', () => {
+      const form = makeForm([{ elements: [{ name: 'q1', title: 'Q' }] }]);
+      const item = { q1: 'val' };
+      const result = pageAnswerGroupsFor(item, form);
+      expect(result[0].pageKey).toBe('page_0');
+      expect(result[0].title).toBe('Seite 1');
+    });
+
+    it('includes comment field for "other" choices', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            {
+              name: 'q1',
+              title: 'Q1',
+              choices: ['A'],
+              showOtherItem: true,
+            },
+          ],
+        },
+      ]);
+      const item = { q1: ['other'], 'q1-Comment': 'Custom answer' };
+      const result = pageAnswerGroupsFor(item, form);
+      const otherChoice = result[0].answers[0].valueListAll?.find(c => c.isOther);
+      expect(otherChoice?.text).toBe('Custom answer');
+      expect(otherChoice?.selected).toBe(true);
+    });
+
+    it('valueListAllDisplay only includes selected items', () => {
+      const form = makeForm([
+        {
+          name: 'p',
+          title: 'P',
+          elements: [
+            {
+              name: 'q1',
+              title: 'Q1',
+              choices: ['A', 'B', 'C'],
+            },
+          ],
+        },
+      ]);
+      const item = { q1: ['A'] };
+      const result = pageAnswerGroupsFor(item, form);
+      const answer = result[0].answers[0];
+      expect(answer.valueListAll).toHaveLength(3);
+      expect(answer.valueListAllDisplay).toHaveLength(1);
+      expect(answer.valueListAllDisplay![0].text).toBe('A');
+    });
+  });
+});

package/tsconfig.json

@@ -1,26 +1,26 @@
-// tsconfig.json
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "esnext",
-    "moduleResolution": "node",
-    "lib": ["esnext", "dom"],
-    "jsx": "preserve",
-    "strict": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "outDir": "dist",
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["src/*"],
-      "@components/*": ["src/components/*"]
-    }
-  },
-  "include": ["src/**/*", "src/**/*.vue"],
-  "exclude": ["node_modules", "dist", "**/*.stories.ts"]
-}
+// tsconfig.json
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "lib": ["esnext", "dom"],
+    "jsx": "preserve",
+    "strict": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@components/*": ["src/components/*"]
+    }
+  },
+  "include": ["src/**/*", "src/**/*.vue"],
+  "exclude": ["node_modules", "dist", "**/*.stories.ts"]
+}

package/vite.config.ts

@@ -1,29 +1,29 @@
-import { defineConfig } from 'vite';
-import vue from '@vitejs/plugin-vue';
-import { resolve } from 'path';
-
-export default defineConfig({
-  plugins: [vue()],
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, './src'),
-      '@components': resolve(__dirname, './src/components'),
-    },
-  },
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'src/index.ts'),
-      name: 'wl-shared-components',
-      fileName: (format) => `wl-shared-components.${format}.js`,
-      formats: ['es', 'umd'],
-    },
-    rollupOptions: {
-      external: ['vue'],
-      output: {
-        globals: {
-          vue: 'Vue',
-        },
-      },
-    },
-  },
-});
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import { resolve } from 'path';
+
+export default defineConfig({
+  plugins: [vue()],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './src'),
+      '@components': resolve(__dirname, './src/components'),
+    },
+  },
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'wl-shared-components',
+      fileName: (format) => `wl-shared-components.${format}.js`,
+      formats: ['es', 'umd'],
+    },
+    rollupOptions: {
+      external: ['vue'],
+      output: {
+        globals: {
+          vue: 'Vue',
+        },
+      },
+    },
+  },
+});