@appsemble/utils 0.20.15 → 0.20.17

package/remap.test.ts

@@ -10,12 +10,13 @@ interface TestCase {
   messages?: AppMessages['messages'];
   userInfo?: UserInfo;
   context?: Record<string, any>;
+  history?: unknown[];
 }
 
 function runTests(tests: Record<string, TestCase>): void {
   it.each(Object.entries(tests))(
     'should %s',
-    (name, { context, expected, input, mappers, messages, userInfo }) => {
+    (name, { context, expected, history, input, mappers, messages, userInfo }) => {
       const result = remap(mappers, input, {
         getMessage: ({ defaultMessage, id }) =>
           new IntlMessageFormat(messages?.messageIds?.[id] ?? defaultMessage),
@@ -23,6 +24,7 @@ function runTests(tests: Record<string, TestCase>): void {
         appUrl: 'https://example.com',
         userInfo,
         context,
+        history,
         appId: 6789,
         locale: 'en',
         pageData: { hello: 'Page data' },
@@ -776,6 +778,51 @@ describe('root', () => {
   });
 });
 
+describe('history', () => {
+  runTests({
+    'return the first history item': {
+      input: { input: 'data' },
+      history: [{ old: 'monke' }, { latest: 'monke' }],
+      mappers: [{ prop: 'input' }, { history: 0 }],
+      expected: { old: 'monke' },
+    },
+  });
+});
+
+describe('assign.history', () => {
+  runTests({
+    'assign the second history item props defined in prop remappers to the output': {
+      input: { input: 'data' },
+      history: [{ old: 'monke' }, { rescue: 'monke', sadge: 'monke' }],
+      mappers: [{ 'assign.history': { index: 1, props: { happy: { prop: 'rescue' } } } }],
+      expected: { input: 'data', happy: 'monke' },
+    },
+  });
+});
+
+describe('omit.history', () => {
+  runTests({
+    'assign the second history item props to the output except omitted props': {
+      input: { input: 'data' },
+      history: [{ old: 'monke' }, { rescue: 'monke', sadge: 'monke' }],
+      mappers: [{ 'omit.history': { index: 1, keys: ['sadge'] } }],
+      expected: { input: 'data', rescue: 'monke' },
+    },
+    'not assign nested omitted props': {
+      input: { input: 'data' },
+      history: [{ rescue: 'monke', nested: { sadge: 'monke', safe: 'monke' } }],
+      mappers: [{ 'omit.history': { index: 0, keys: [['nested', 'sadge']] } }],
+      expected: { input: 'data', rescue: 'monke', nested: { safe: 'monke' } },
+    },
+    'handle non existing properties': {
+      input: { input: 'data' },
+      history: [{ rescue: 'monke', nested: { happy: 'monke', safe: 'monke' } }],
+      mappers: [{ 'omit.history': { index: 0, keys: [['nested', 'nonexistent']] } }],
+      expected: { input: 'data', rescue: 'monke', nested: { happy: 'monke', safe: 'monke' } },
+    },
+  });
+});
+
 describe('string.case', () => {
   runTests({
     'convert a string to upper case': {

package/remap.ts

@@ -79,6 +79,7 @@ export interface RemapperContext {
 
 interface InternalContext extends RemapperContext {
   root?: unknown;
+  history?: unknown[];
 
   array?: {
     index: number;
@@ -352,6 +353,32 @@ const mapperImplementations: MapperImplementations = {
 
   root: (args, input, context) => context.root,
 
+  history: (index, input, context) => context.history?.[index],
+
+  'assign.history': ({ index, props }, input: any, context) => ({
+    ...input,
+    ...mapValues(props, (mapper) => remap(mapper, context.history[index], context)),
+  }),
+
+  'omit.history'({ index, keys }, input: Record<string, any>, context) {
+    const result = { ...(context.history[index] as Record<string, any>) };
+    for (const key of keys) {
+      if (Array.isArray(key)) {
+        key.reduce((acc, k, i) => {
+          if (i === key.length - 1) {
+            delete acc[k];
+          } else {
+            return acc?.[k];
+          }
+          return acc;
+        }, result);
+      } else {
+        delete result[key];
+      }
+    }
+    return { ...input, ...result };
+  },
+
   'string.case'(stringCase, input) {
     if (stringCase === 'lower') {
       return String(input).toLowerCase();

package/types.ts

@@ -4,5 +4,3 @@ declare global {
     function supportedValuesOf(value: string): string[];
   }
 }
-
-export {};