p-elements-core 1.2.30 → 1.2.32-rc-10

package/src/maquette/jsx.ts

@@ -1,61 +1,61 @@
-import { VNode, VNodeChild, VNodeProperties } from "./interfaces";
-
-declare global {
-  function jsx(
-    tagName: string,
-    properties: VNodeProperties | null,
-    ...children: (VNode | string)[]
-  ): VNode;
-}
-
-let toTextVNode = (data: any): VNode => {
-  return {
-    vnodeSelector: "",
-    properties: undefined,
-    children: undefined,
-    text: data.toString(),
-    domNode: null,
-  };
-};
-
-let appendChildren = (insertions: any[], main: VNode[]) => {
-  for (let i = 0, length = insertions.length; i < length; i++) {
-    let item = insertions[i];
-    if (Array.isArray(item)) {
-      appendChildren(item, main);
-    } else {
-      if (item !== null && item !== undefined && item !== false) {
-        if (!item.hasOwnProperty("vnodeSelector")) {
-          item = toTextVNode(item);
-        }
-        main.push(item);
-      }
-    }
-  }
-};
-
-export let jsx = (
-  tagName: string,
-  properties: VNodeProperties | null,
-  ...childNodes: VNodeChild[]
-): VNode => {
-  if (childNodes.length === 1 && typeof childNodes[0] === "string") {
-    return {
-      vnodeSelector: tagName,
-      properties: properties || undefined,
-      children: undefined,
-      text: childNodes[0],
-      domNode: null,
-    };
-  }
-  let children: VNode[] = [];
-  appendChildren(childNodes, children);
-  return {
-    vnodeSelector: tagName,
-    properties: properties || undefined,
-    children: children,
-    text: undefined,
-    domNode: null,
-  };
-};
-
+import { VNode, VNodeChild, VNodeProperties } from "./interfaces";
+
+declare global {
+  function jsx(
+    tagName: string,
+    properties: VNodeProperties | null,
+    ...children: (VNode | string)[]
+  ): VNode;
+}
+
+let toTextVNode = (data: any): VNode => {
+  return {
+    vnodeSelector: "",
+    properties: undefined,
+    children: undefined,
+    text: data.toString(),
+    domNode: null,
+  };
+};
+
+let appendChildren = (insertions: any[], main: VNode[]) => {
+  for (let i = 0, length = insertions.length; i < length; i++) {
+    let item = insertions[i];
+    if (Array.isArray(item)) {
+      appendChildren(item, main);
+    } else {
+      if (item !== null && item !== undefined && item !== false) {
+        if (!item.hasOwnProperty("vnodeSelector")) {
+          item = toTextVNode(item);
+        }
+        main.push(item);
+      }
+    }
+  }
+};
+
+export let jsx = (
+  tagName: string,
+  properties: VNodeProperties | null,
+  ...childNodes: VNodeChild[]
+): VNode => {
+  if (childNodes.length === 1 && typeof childNodes[0] === "string") {
+    return {
+      vnodeSelector: tagName,
+      properties: properties || undefined,
+      children: undefined,
+      text: childNodes[0],
+      domNode: null,
+    };
+  }
+  let children: VNode[] = [];
+  appendChildren(childNodes, children);
+  return {
+    vnodeSelector: tagName,
+    properties: properties || undefined,
+    children: children,
+    text: undefined,
+    domNode: null,
+  };
+};
+

package/src/maquette/mapping.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Tests for Maquette mapping module
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createMapping } from './mapping.js';
+
+describe('Maquette mapping', () => {
+  describe('createMapping', () => {
+    interface TestSource {
+      id: number;
+      name: string;
+    }
+
+    interface TestTarget {
+      sourceId: number;
+      displayName: string;
+    }
+
+    it('should create a mapping instance', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      expect(mapping).toBeDefined();
+      expect(mapping.results).toBeDefined();
+      expect(mapping.map).toBeDefined();
+      expect(Array.isArray(mapping.results)).toBe(true);
+    });
+
+    it('should create initial results from sources', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      const sources = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ];
+
+      mapping.map(sources);
+
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(1);
+      expect(mapping.results[0].displayName).toBe('Alice');
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(3);
+    });
+
+    it('should update existing results when sources change', () => {
+      let createCount = 0;
+      let updateCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          updateCount++;
+          target.displayName = source.name;
+        }
+      );
+
+      // Initial mapping
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+      ]);
+
+      expect(createCount).toBe(2);
+      expect(updateCount).toBe(0);
+
+      // Update with same keys but different names
+      mapping.map([
+        { id: 1, name: 'Alice Updated' },
+        { id: 2, name: 'Bob Updated' },
+      ]);
+
+      expect(createCount).toBe(2); // No new creates
+      expect(updateCount).toBe(2); // Both updated
+      expect(mapping.results[0].displayName).toBe('Alice Updated');
+      expect(mapping.results[1].displayName).toBe('Bob Updated');
+    });
+
+    it('should add new items', () => {
+      let createCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([{ id: 1, name: 'Alice' }]);
+      expect(createCount).toBe(1);
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(createCount).toBe(3);
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[2].sourceId).toBe(3);
+    });
+
+    it('should remove items', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(mapping.results.length).toBe(3);
+
+      mapping.map([{ id: 2, name: 'Bob' }]);
+
+      expect(mapping.results.length).toBe(1);
+      expect(mapping.results[0].sourceId).toBe(2);
+    });
+
+    it('should handle reordering of items', () => {
+      let createCount = 0;
+      let updateCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          updateCount++;
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      const originalResults = [...mapping.results];
+
+      // Reverse order
+      mapping.map([
+        { id: 3, name: 'Charlie' },
+        { id: 2, name: 'Bob' },
+        { id: 1, name: 'Alice' },
+      ]);
+
+      // Should reuse existing results, not create new ones
+      expect(createCount).toBe(3);
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(3);
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(1);
+      
+      // Results should be reordered, not recreated
+      expect(mapping.results[0]).toBe(originalResults[2]);
+      expect(mapping.results[1]).toBe(originalResults[1]);
+      expect(mapping.results[2]).toBe(originalResults[0]);
+    });
+
+    it('should handle mixed add, remove, reorder operations', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      mapping.map([
+        { id: 4, name: 'David' },  // New
+        { id: 2, name: 'Bob' },     // Existing, reordered
+        { id: 5, name: 'Eve' },     // New
+      ]);
+
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(4);
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(5);
+    });
+
+    it('should handle string keys', () => {
+      interface StringKeySource {
+        key: string;
+        value: number;
+      }
+
+      const mapping = createMapping<StringKeySource, { val: number }>(
+        (source) => source.key,
+        (source) => ({ val: source.value }),
+        (source, target) => {
+          target.val = source.value;
+        }
+      );
+
+      mapping.map([
+        { key: 'a', value: 1 },
+        { key: 'b', value: 2 },
+      ]);
+
+      expect(mapping.results.length).toBe(2);
+      expect(mapping.results[0].val).toBe(1);
+      expect(mapping.results[1].val).toBe(2);
+    });
+
+    it('should pass correct index to createResult and updateResult', () => {
+      const createdIndexes: number[] = [];
+      const updatedIndexes: number[] = [];
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source, index) => {
+          createdIndexes.push(index);
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target, index) => {
+          updatedIndexes.push(index);
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(createdIndexes).toEqual([0, 1, 2]);
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(updatedIndexes).toEqual([0, 1, 2]);
+    });
+
+    it('should handle empty arrays', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([]);
+      expect(mapping.results.length).toBe(0);
+
+      mapping.map([{ id: 1, name: 'Alice' }]);
+      expect(mapping.results.length).toBe(1);
+
+      mapping.map([]);
+      expect(mapping.results.length).toBe(0);
+    });
+  });
+});

package/src/maquette/mapping.ts

@@ -1,56 +1,56 @@
-import { Mapping } from "./interfaces";
-
-/**
- * Creates a {@link Mapping} instance that keeps an array of result objects synchronized with an array of source objects.
- * See {@link http://maquettejs.org/docs/arrays.html Working with arrays}.
- *
- * @param <Source>       The type of source items. A database-record for instance.
- * @param <Target>       The type of target items. A [[MaquetteComponent]] for instance.
- * @param getSourceKey   `function(source)` that must return a key to identify each source object. The result must either be a string or a number.
- * @param createResult   `function(source, index)` that must create a new result object from a given source. This function is identical
- *                       to the `callback` argument in `Array.map(callback)`.
- * @param updateResult   `function(source, target, index)` that updates a result to an updated source.
- */
-export let createMapping = <Source, Target>(
-  getSourceKey: (source: Source) => string | number,
-  createResult: (source: Source, index: number) => Target,
-  updateResult: (source: Source, target: Target, index: number) => void
-): Mapping<Source, Target> => {
-  let keys = [] as unknown[];
-  let results = [] as Target[];
-
-  return {
-    results: results,
-    map: (newSources: Source[]) => {
-      let newKeys = newSources.map(getSourceKey);
-      let oldTargets = results.slice();
-      let oldIndex = 0;
-      for (let i = 0; i < newSources.length; i++) {
-        let source = newSources[i];
-        let sourceKey = newKeys[i];
-        if (sourceKey === keys[oldIndex]) {
-          results[i] = oldTargets[oldIndex];
-          updateResult(source, oldTargets[oldIndex], i);
-          oldIndex++;
-        } else {
-          let found = false;
-          for (let j = 1; j < keys.length + 1; j++) {
-            let searchIndex = (oldIndex + j) % keys.length;
-            if (keys[searchIndex] === sourceKey) {
-              results[i] = oldTargets[searchIndex];
-              updateResult(newSources[i], oldTargets[searchIndex], i);
-              oldIndex = searchIndex + 1;
-              found = true;
-              break;
-            }
-          }
-          if (!found) {
-            results[i] = createResult(source, i);
-          }
-        }
-      }
-      results.length = newSources.length;
-      keys = newKeys;
-    },
-  };
-};
+import { Mapping } from "./interfaces";
+
+/**
+ * Creates a {@link Mapping} instance that keeps an array of result objects synchronized with an array of source objects.
+ * See {@link http://maquettejs.org/docs/arrays.html Working with arrays}.
+ *
+ * @param <Source>       The type of source items. A database-record for instance.
+ * @param <Target>       The type of target items. A [[MaquetteComponent]] for instance.
+ * @param getSourceKey   `function(source)` that must return a key to identify each source object. The result must either be a string or a number.
+ * @param createResult   `function(source, index)` that must create a new result object from a given source. This function is identical
+ *                       to the `callback` argument in `Array.map(callback)`.
+ * @param updateResult   `function(source, target, index)` that updates a result to an updated source.
+ */
+export let createMapping = <Source, Target>(
+  getSourceKey: (source: Source) => string | number,
+  createResult: (source: Source, index: number) => Target,
+  updateResult: (source: Source, target: Target, index: number) => void
+): Mapping<Source, Target> => {
+  let keys = [] as unknown[];
+  let results = [] as Target[];
+
+  return {
+    results: results,
+    map: (newSources: Source[]) => {
+      let newKeys = newSources.map(getSourceKey);
+      let oldTargets = results.slice();
+      let oldIndex = 0;
+      for (let i = 0; i < newSources.length; i++) {
+        let source = newSources[i];
+        let sourceKey = newKeys[i];
+        if (sourceKey === keys[oldIndex]) {
+          results[i] = oldTargets[oldIndex];
+          updateResult(source, oldTargets[oldIndex], i);
+          oldIndex++;
+        } else {
+          let found = false;
+          for (let j = 1; j < keys.length + 1; j++) {
+            let searchIndex = (oldIndex + j) % keys.length;
+            if (keys[searchIndex] === sourceKey) {
+              results[i] = oldTargets[searchIndex];
+              updateResult(newSources[i], oldTargets[searchIndex], i);
+              oldIndex = searchIndex + 1;
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            results[i] = createResult(source, i);
+          }
+        }
+      }
+      results.length = newSources.length;
+      keys = newKeys;
+    },
+  };
+};