@pcg/dynamic-components 1.0.0-alpha.0

package/tests/paths/array-keys.test.ts

@@ -0,0 +1,182 @@
+import {
+  describe, expect, test,
+} from 'vitest';
+import {
+  createIdArrayKey,
+  createPositionArrayKey, extractIdFromArrayKey, extractPositionFromArrayKey, getIndexByArrayKey, isArrayKey, isIdArrayKey, isPositionArrayKey,
+} from '../../src/paths/index.js';
+
+describe('Position Array Key', () => {
+  describe('isPositionArrayKey', () => {
+    test.each([
+      'pos:a0',
+      'pos:Zz',
+    ])('must return true for correct position array key', (key) => {
+      expect(isPositionArrayKey(key)).toBeTruthy();
+    });
+
+    test.each([
+      0,
+      null,
+      'xx2245x',
+      'ps:mpdf:xxxxx',
+      'pos2355',
+    ])('must return false for invalid position array key', (key) => {
+      expect(isPositionArrayKey(key)).toBeFalsy();
+    });
+  });
+
+  describe('createPositionArrayKey', () => {
+    test('must create position array key', () => {
+      const key = createPositionArrayKey('a0');
+      expect(isPositionArrayKey(key)).toBeTruthy();
+    });
+  });
+
+  describe('extractPositionFromArrayKey', () => {
+    test('must extract position from array key', () => {
+      const key = createPositionArrayKey('a0');
+      expect(extractPositionFromArrayKey(key)).toBe('a0');
+    });
+
+    test('must throw error on invalid array key', () => {
+      expect(() => {
+        extractPositionFromArrayKey('invalid_key');
+      }).toThrowError(/^Invalid array key/);
+    });
+  });
+});
+
+describe('Id Array Key', () => {
+  describe('isIdArrayKey', () => {
+    test.each([
+      'id:xxx',
+      'id:mpdf:xxxxx',
+    ])('must return true for correct id array key', (key) => {
+      expect(isIdArrayKey(key)).toBeTruthy();
+    });
+
+    test.each([
+      0,
+      null,
+      'xx2245x',
+      'pos:2355',
+    ])('must return false for invalid id array key', (key) => {
+      expect(isIdArrayKey(key)).toBeFalsy();
+    });
+  });
+
+  describe('createIdArrayKey', () => {
+    test('must create id array key', () => {
+      const key = createIdArrayKey('xxx');
+      expect(isIdArrayKey(key)).toBeTruthy();
+    });
+  });
+
+  describe('extractIdFromArrayKey', () => {
+    test('must extract id from array key', () => {
+      const key = createIdArrayKey('xxx');
+      expect(extractIdFromArrayKey(key)).toBe('xxx');
+    });
+
+    test('must throw error on invalid array key', () => {
+      expect(() => {
+        extractIdFromArrayKey('invalid_key');
+      }).toThrowError(/^Invalid array key/);
+    });
+  });
+});
+
+describe('isArrayKey', () => {
+  test.each([
+    'pos:a0',
+    'pos:Zz',
+    'id:xxx',
+    'id:mpdf:xxx',
+  ])('must return true for correct array key', (key) => {
+    expect(isArrayKey(key)).toBeTruthy();
+  });
+
+  test.each([
+    0,
+    null,
+    'xx2245x',
+    'ids:xx:xxx',
+    'ps:mpdf:xxxxx',
+    'pos2355',
+  ])('must return false for invalid array key', (key) => {
+    expect(isArrayKey(key)).toBeFalsy();
+  });
+});
+
+describe('getIndexByArrayKey', () => {
+  test('must throw error on non-array type', () => {
+    expect(() => {
+      getIndexByArrayKey({
+      }, 'pos:a2');
+    }).toThrowError(/^Can't use array key in non array type/);
+  });
+
+  test('must extract index from position key', () => {
+    const array = [
+      {
+        position: 'a2',
+      },
+      {
+        position: 'a0',
+      },
+      {
+        position: 'a1',
+      },
+    ];
+
+    expect(getIndexByArrayKey(array, 'pos:a0')).toBe(1);
+  });
+
+  test('must extract index from id key', () => {
+    const array = [
+      {
+        id: 'x',
+      },
+      {
+        id: 'z',
+      },
+      {
+        id: 'y',
+      },
+    ];
+
+    expect(getIndexByArrayKey(array, 'id:z')).toBe(1);
+  });
+
+  test('must throw error on unknown array key', () => {
+    expect(() => {
+      getIndexByArrayKey([], 'type:article');
+    }).toThrowError(/^Unknown array key type/);
+  });
+
+  test('must throw error on undefined array item', () => {
+    const array = [
+      {
+        id: 'x',
+        position: 'a2',
+      },
+      {
+        id: 'z',
+        position: 'a0',
+      },
+      {
+        id: 'y',
+        position: 'a1',
+      },
+    ];
+
+    expect(() => {
+      getIndexByArrayKey(array, 'pos:a3');
+    }).toThrowError(/^Can't find index by position/);
+
+    expect(() => {
+      getIndexByArrayKey(array, 'id:q');
+    }).toThrowError(/^Can't find index by id/);
+  });
+});

package/tests/paths/array-ops.test.ts

@@ -0,0 +1,164 @@
+import { DynamicComponentWithPosition } from '@/dynamic-components/index.js';
+import {
+  describe, expect, test,
+} from 'vitest';
+import {
+  insertInPath, moveInPath, pullFromPath, pushInPath,
+} from '../../src/paths/index.js';
+
+describe('pushInPath', () => {
+  test('must push in root array', () => {
+    const items: string[] = [];
+
+    pushInPath(items, [], 'Item');
+
+    expect(items[0]).toBe('Item');
+  });
+
+  test('must push in array by deep path', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+          tags: [],
+        },
+        {
+          position: 'a1',
+          tags: [],
+        },
+      ],
+    };
+
+    pushInPath(object, ['items', 'pos:a1', 'tags'], 'New Tag');
+
+    expect(object.items[1].tags[0]).toBe('New Tag');
+  });
+
+  test('must recreate path and push item', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const object: any = {
+      id: 'xxx',
+    };
+
+    pushInPath(object, ['items', 0, 'tags'], 'New Tag');
+
+    expect(object.items?.[0]?.tags?.[0]).toBe('New Tag');
+  });
+});
+
+describe('insertInPath', () => {
+  test('must push in root array', () => {
+    const items: string[] = [
+      'One',
+      'Two',
+      'Three',
+    ];
+
+    insertInPath(items, [], 1, ['Foo', 'Bar']);
+
+    expect(items).toEqual([
+      'One',
+      'Foo',
+      'Bar',
+      'Two',
+      'Three',
+    ]);
+
+    insertInPath(items, [], 10, ['Baz']);
+
+    expect(items[items.length - 1]).toBe('Baz');
+  });
+
+  test('must push in array by position key', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+        },
+        {
+          position: 'a1',
+        },
+      ],
+    };
+
+    insertInPath(object, ['items'], 'pos:a0', [{
+      position: 'a01',
+      tags: [],
+    }]);
+
+    expect(object.items[0].position).toBe('a01');
+  });
+
+  test.only('must push component to root array', () => {
+    const components: DynamicComponentWithPosition[] = [];
+
+    insertInPath(components, [], 0, [{
+      id: 'xxx',
+      component: 'text-input',
+      props: {
+      },
+    }]);
+
+    expect(components[0].id).toBe('xxx');
+  });
+});
+
+describe('pullFromPath', () => {
+  test('must pull from array by index', () => {
+    const object = {
+      items: [
+        'One',
+        'Two',
+        'Three',
+      ],
+    };
+
+    pullFromPath(object, ['items'], 1);
+
+    expect(object.items[1]).toBe('Three');
+  });
+
+  test('must pull from array by id key', () => {
+    const object = {
+      items: [
+        {
+          id: 'x',
+        },
+        {
+          id: 'y',
+        },
+        {
+          id: 'z',
+        },
+      ],
+    };
+
+    pullFromPath(object, ['items'], 'id:y');
+
+    expect(object.items[1].id).toBe('z');
+  });
+});
+
+describe('moveInPath', () => {
+  // new test for moveInPath
+  test('must move item in array by position key', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+        },
+        {
+          position: 'a1',
+        },
+        {
+          position: 'a2',
+        },
+      ],
+    };
+
+    moveInPath(object, ['items'], 'a1', 'a0', 'before');
+
+    expect(object.items[0].position).toBe('a1');
+    expect(object.items[1].position).toBe('a0');
+  });
+});

package/tests/paths/basic-ops.test.ts

@@ -0,0 +1,263 @@
+import {
+  describe, expect, test,
+} from 'vitest';
+import {
+  existsInPath,
+  getFromPath,
+  isSamePath,
+  setInPath, unsetPath,
+} from '../../src/paths/index.js';
+
+describe('getFromPath', () => {
+  test('must return root item on root path', () => {
+    const array = [
+      {
+        id: 'xx',
+      },
+    ];
+
+    expect(Array.isArray(getFromPath(array, []))).toBeTruthy();
+  });
+
+  test('must return undefined on non container argument', () => {
+    expect(getFromPath(undefined, [])).toBeUndefined();
+  });
+
+  test('must get item from simple path', () => {
+    const object = {
+      items: [
+        {
+          id: 'xxx',
+        },
+      ],
+    };
+
+    expect(getFromPath(object, ['items', 0, 'id'])).toBe('xxx');
+  });
+
+  test('must get item from complex path', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+          tags: [{
+            id: 'tag1',
+            alias: 'Foo',
+          }],
+        },
+        {
+          position: 'a1',
+          tags: [{
+            id: 'tag2',
+            alias: 'Bar',
+          }, {
+            id: 'tag3',
+            alias: 'Baz',
+          }],
+        },
+      ],
+    };
+
+    expect(getFromPath(object, ['items', 'pos:a1', 'tags', 'id:tag2', 'alias'])).toBe('Bar');
+  });
+});
+
+describe('setInPath', () => {
+  test('must set item in array', () => {
+    const object = {
+      items: [
+        'One',
+        'Two',
+        'Three',
+      ],
+    };
+
+    setInPath(object, ['items', 1], 'Updated');
+    expect(getFromPath(object, ['items', 1])).toBe('Updated');
+  });
+
+  test('must set in simple path', () => {
+    const object = {
+      items: [
+        {
+          id: 'xxx',
+          title: 'Hello',
+        },
+      ],
+    };
+
+    setInPath(object, ['items', 0, 'title'], 'World');
+    expect(getFromPath(object, ['items', 0, 'title'])).toBe('World');
+  });
+
+  test('must set in complex path', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+          tags: [{
+            id: 'tag1',
+            alias: 'Foo',
+          }],
+        },
+        {
+          position: 'a1',
+          tags: [{
+            id: 'tag2',
+            alias: 'Bar',
+          }, {
+            id: 'tag3',
+            alias: 'Baz',
+          }],
+        },
+      ],
+    };
+
+    setInPath(object, ['items', 'pos:a1', 'tags', 'id:tag2', 'alias'], 'Updated');
+    expect(getFromPath(object, ['items', 'pos:a1', 'tags', 'id:tag2', 'alias'])).toBe('Updated');
+  });
+
+  test('must recreate complex path and set', () => {
+    const object = {
+    };
+
+    setInPath(object, ['items', 0, 'tags', 0, 'alias'], 'Foo');
+    expect(object).toMatchObject({
+      items: [
+        {
+          tags: [
+            {
+              alias: 'Foo',
+            },
+          ],
+        },
+      ],
+    });
+  });
+});
+
+describe('unsetPath', () => {
+  test('must unset value in simple path', () => {
+    const object = {
+      items: [
+        {
+          id: 'xxx',
+          title: 'Hello',
+        },
+      ],
+    };
+
+    expect(getFromPath(object, ['items', 0, 'title'])).toBe('Hello');
+
+    unsetPath(object, ['items', 0, 'title']);
+
+    expect(getFromPath(object, ['items', 0, 'title'])).toBeUndefined();
+  });
+
+  test('must unset in complex path', () => {
+    const object = {
+      items: [
+        {
+          position: 'a0',
+          tags: [{
+            id: 'tag1',
+            alias: 'Foo',
+          }],
+        },
+        {
+          position: 'a1',
+          tags: [{
+            id: 'tag2',
+            alias: 'Bar',
+          }, {
+            id: 'tag3',
+            alias: 'Baz',
+          }],
+        },
+      ],
+    };
+
+    expect(getFromPath(object, ['items', 'pos:a1', 'tags', 'id:tag3', 'alias'])).toBe('Baz');
+
+    unsetPath(object, ['items', 'pos:a1', 'tags', 'id:tag3', 'alias']);
+
+    expect(getFromPath(object, ['items', 'pos:a1', 'tags', 'id:tag3', 'alias'])).toBeUndefined();
+  });
+});
+
+describe('existsInPath', () => {
+  test('must return true for existing simple path', () => {
+    const object = {
+      items: [
+        {
+          id: 'xxx',
+          title: 'Hello',
+        },
+      ],
+    };
+
+    expect(existsInPath(object, ['items', 0, 'title'])).toBe(true);
+  });
+
+  test('must return false for non-existing simple path', () => {
+    const object = {
+      items: [
+        {
+          id: 'xxx',
+        },
+      ],
+    };
+
+    expect(existsInPath(object, ['items', 0, 'title'])).toBe(false);
+  });
+
+  test('must return true for existing complex path', () => {
+    const object = {
+      items: [
+        {
+          position: 'a1',
+          tags: [{
+            id: 'tag2',
+            alias: 'Bar',
+          }],
+        },
+      ],
+    };
+
+    expect(existsInPath(object, ['items', 'pos:a1', 'tags', 'id:tag2', 'alias'])).toBe(true);
+  });
+
+  test('must return false for undefined object', () => {
+    expect(existsInPath(undefined, ['items', 0, 'title'])).toBe(false);
+  });
+
+  test('must return true for root path on existing object', () => {
+    const object = {
+      items: [],
+    };
+
+    expect(existsInPath(object, [])).toBe(true);
+  });
+});
+
+describe('isSamePath', () => {
+  test('must return true for identical simple paths', () => {
+    expect(isSamePath(['items', 0, 'name'], ['items', 0, 'name'])).toBe(true);
+  });
+
+  test('must return false for different simple paths', () => {
+    expect(isSamePath(['items', 0, 'name'], ['items', 1, 'name'])).toBe(false);
+  });
+
+  test('must return false for paths of different lengths', () => {
+    expect(isSamePath(['items', 0], ['items', 0, 'name'])).toBe(false);
+  });
+
+  test('must return true for empty paths', () => {
+    expect(isSamePath([], [])).toBe(true);
+  });
+
+  test('must return false when comparing empty path with non-empty path', () => {
+    expect(isSamePath([], ['items'])).toBe(false);
+  });
+});

package/tests/paths/tools.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'vitest';
+import {
+  joinPath,
+  sortByPosition,
+} from '../../src/paths/tools.js';
+
+describe('joinPath', () => {
+  test('must join one path item', () => {
+    expect(joinPath([0], 'props')).toEqual([0, 'props']);
+  });
+
+  test('must join multiple path items', () => {
+    expect(joinPath([0], 'props', 'components')).toEqual([0, 'props', 'components']);
+  });
+
+  test('must throw error on invalid path', () => {
+    expect(() => {
+      // @ts-expect-error for test
+      joinPath(0, 'props');
+    }).toThrowError(/^path must be array/);
+  });
+
+  test('must throw error on invalid path item', () => {
+    expect(() => {
+      // @ts-expect-error for test
+      joinPath([0], new RegExp('props'));
+    }).toThrowError(/^Invalid path item/);
+  });
+});
+
+describe('sortByPosition', () => {
+  test('must sort by position', () => {
+    const unsorted = [{
+      position: 'a2',
+    }, {
+      position: 'a2',
+    }, {
+      position: 'a0',
+    }, {
+      position: 'a1',
+    }];
+
+    const sorted = [{
+      position: 'a0',
+    }, {
+      position: 'a1',
+    }, {
+      position: 'a2',
+    }, {
+      position: 'a2',
+    }];
+
+    expect(unsorted.sort((a, b) => sortByPosition(a.position, b.position))).toEqual(sorted);
+  });
+});