@appsemble/lang-sdk 0.36.3-test.6 → 0.36.4

package/examples.d.ts

@@ -4,9 +4,10 @@ export interface RemapperExample {
     input: unknown;
     remapper: unknown;
     result: unknown;
+    history?: unknown[];
     skip?: boolean;
 }
-type CustomRemapperKeys = 'app.id' | 'app.locale' | 'app.url' | 'array.map.1' | 'if.else' | 'if.then' | 'None';
+type CustomRemapperKeys = 'app.id' | 'app.locale' | 'app.url' | 'array.map.1' | 'array.range.1' | 'array.range.map' | 'array.range' | 'array.sort.by' | 'array.sort.desc' | 'array.sort.numeric' | 'date.endOf.quarter' | 'date.endOf.week' | 'date.endOf.weekSun' | 'date.endOf.year' | 'date.endOf' | 'date.set' | 'date.startOf.quarter' | 'date.startOf.week' | 'date.startOf.weekSun' | 'date.startOf.year' | 'date.startOf' | 'if.else' | 'if.then' | 'None';
 export type RemapperExampleKeys = CustomRemapperKeys | Exclude<keyof Remappers, 'app' | 'if'>;
 export declare const examples: Record<RemapperExampleKeys, RemapperExample>;
 /**
@@ -19,5 +20,5 @@ export declare function schemaExample(remapper: keyof typeof examples, options?:
     result?: 'inline' | 'pretty';
     exclude?: ('input' | 'remapper' | 'result')[];
 }): string;
-export declare function createExampleContext(url: URL, lang: string, userInfo?: AppMemberInfo, history?: []): RemapperContext;
+export declare function createExampleContext(url: URL, lang: string, userInfo?: AppMemberInfo, history?: unknown[]): RemapperContext;
 export {};

package/examples.js

@@ -216,6 +216,42 @@ export const examples = {
         },
         result: "id eq '5' or id eq '6' or id eq '7'",
     },
+    'array.groupBy': {
+        input: [
+            { name: 'Alice', department: 'Engineering' },
+            { name: 'Bob', department: 'Sales' },
+            { name: 'Charlie', department: 'Engineering' },
+        ],
+        remapper: {
+            'array.groupBy': 'department',
+        },
+        result: [
+            {
+                key: 'Engineering',
+                items: [
+                    { name: 'Alice', department: 'Engineering' },
+                    { name: 'Charlie', department: 'Engineering' },
+                ],
+            },
+            {
+                key: 'Sales',
+                items: [{ name: 'Bob', department: 'Sales' }],
+            },
+        ],
+    },
+    'array.toObject': {
+        input: [
+            { key: 'Engineering', items: ['Alice', 'Charlie'] },
+            { key: 'Sales', items: ['Bob'] },
+        ],
+        remapper: {
+            'array.toObject': { key: { prop: 'key' }, value: { prop: 'items' } },
+        },
+        result: {
+            Engineering: ['Alice', 'Charlie'],
+            Sales: ['Bob'],
+        },
+    },
     'array.map': {
         input: [
             {
@@ -300,6 +336,44 @@ export const examples = {
             },
         ],
     },
+    'array.range': {
+        input: null,
+        remapper: {
+            'array.range': 4,
+        },
+        result: [0, 1, 2, 3],
+    },
+    'array.range.1': {
+        input: 5,
+        remapper: {
+            'array.range': { root: null },
+        },
+        result: [0, 1, 2, 3, 4],
+    },
+    'array.range.map': {
+        input: 3,
+        remapper: [
+            { 'array.range': { root: null } },
+            {
+                'array.map': {
+                    'object.from': {
+                        index: { array: 'item' },
+                        message: {
+                            'string.format': {
+                                template: 'Item {i}',
+                                values: { i: { array: 'item' } },
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+        result: [
+            { index: 0, message: 'Item 0' },
+            { index: 1, message: 'Item 1' },
+            { index: 2, message: 'Item 2' },
+        ],
+    },
     'array.omit': {
         input: [
             {
@@ -337,6 +411,42 @@ export const examples = {
             },
         ],
     },
+    'array.sort': {
+        input: [3, 1, 4, 1, 5, 9, 2, 6],
+        remapper: {
+            'array.sort': null,
+        },
+        result: [1, 1, 2, 3, 4, 5, 6, 9],
+    },
+    'array.sort.by': {
+        input: [
+            { name: 'Charlie', age: 30 },
+            { name: 'Alice', age: 25 },
+            { name: 'Bob', age: 35 },
+        ],
+        remapper: {
+            'array.sort': 'name',
+        },
+        result: [
+            { name: 'Alice', age: 25 },
+            { name: 'Bob', age: 35 },
+            { name: 'Charlie', age: 30 },
+        ],
+    },
+    'array.sort.desc': {
+        input: [3, 1, 4, 1, 5, 9, 2, 6],
+        remapper: {
+            'array.sort': { descending: true },
+        },
+        result: [9, 6, 5, 4, 3, 2, 1, 1],
+    },
+    'array.sort.numeric': {
+        input: ['10', '2', '1', '20'],
+        remapper: {
+            'array.sort': { strategy: 'numeric' },
+        },
+        result: ['1', '2', '10', '20'],
+    },
     'array.unique': {
         input: [1, 1, 2, 3],
         remapper: {
@@ -415,6 +525,71 @@ export const examples = {
         result: 'Tue Feb 11 2014 00:00:00',
         skip: true,
     },
+    'date.startOf': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.startOf': 'month' },
+        result: '2025-11-01T00:00:00.000Z',
+        skip: true,
+    },
+    'date.startOf.year': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.startOf': 'year' },
+        result: '2025-01-01T00:00:00.000Z',
+        skip: true,
+    },
+    'date.startOf.quarter': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.startOf': 'quarter' },
+        result: '2025-10-01T00:00:00.000Z',
+        skip: true,
+    },
+    'date.startOf.week': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.startOf': 'week' },
+        result: '2025-11-17T00:00:00.000Z',
+        skip: true,
+    },
+    'date.startOf.weekSun': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.startOf': 'weekSun' },
+        result: '2025-11-16T00:00:00.000Z',
+        skip: true,
+    },
+    'date.endOf': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.endOf': 'month' },
+        result: '2025-11-30T23:59:59.999Z',
+        skip: true,
+    },
+    'date.endOf.year': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.endOf': 'year' },
+        result: '2025-12-31T23:59:59.999Z',
+        skip: true,
+    },
+    'date.endOf.quarter': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.endOf': 'quarter' },
+        result: '2025-12-31T23:59:59.999Z',
+        skip: true,
+    },
+    'date.endOf.week': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.endOf': 'week' },
+        result: '2025-11-23T23:59:59.999Z',
+        skip: true,
+    },
+    'date.endOf.weekSun': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.endOf': 'weekSun' },
+        result: '2025-11-22T23:59:59.999Z',
+        skip: true,
+    },
+    'date.set': {
+        input: '2025-11-21T12:00:00.000Z',
+        remapper: { 'date.set': { year: 2026, month: 1, day: 1 } },
+        result: '2026-01-01T12:00:00.000Z',
+    },
     equals: {
         input: { inputValue: 'example', expectedValue: 'example' },
         remapper: {
@@ -433,6 +608,11 @@ export const examples = {
         remapper: { gt: [{ prop: 'stock' }, 5] },
         result: true,
     },
+    gte: {
+        input: { stock: 5 },
+        remapper: { gte: [{ prop: 'stock' }, 5] },
+        result: true,
+    },
     history: {
         input: null,
         remapper: {},
@@ -500,6 +680,11 @@ export const examples = {
         remapper: { lt: [{ prop: 'stock' }, 5] },
         result: true,
     },
+    lte: {
+        input: { stock: 5 },
+        remapper: { lte: [{ prop: 'stock' }, 5] },
+        result: true,
+    },
     match: {
         input: { Gem: 'Ruby' },
         remapper: {
@@ -929,6 +1114,83 @@ export const examples = {
         },
         result: [true, true, true, false, false],
     },
+    focus: {
+        input: null,
+        history: [
+            [
+                { id: 'customer1', name: 'Customer 1' },
+                { id: 'customer2', name: 'Customer 2' },
+                { id: 'customer3', name: 'Customer 3' },
+            ],
+            [
+                { id: 'orderA', customerId: 'customer1', value: 'Order A for Customer 1' },
+                { id: 'orderB', customerId: 'customer2', value: 'Order B for Customer 2' },
+                { id: 'orderC', customerId: 'customer1', value: 'Order C for Customer 1' },
+                { id: 'orderD', customerId: 'customer3', value: 'Order D for Customer 3' },
+                { id: 'orderE', customerId: 'customer1', value: 'Order E for Customer 1' },
+                { id: 'orderF', customerId: 'customer2', value: 'Order F for Customer 2' },
+            ],
+        ],
+        remapper: [
+            { history: 0 },
+            {
+                'array.map': {
+                    focus: {
+                        on: {
+                            'object.from': {
+                                currentCustomer: { array: 'item' },
+                                allOrders: { history: 1 },
+                            },
+                        },
+                        do: {
+                            'object.from': {
+                                id: { prop: 'id' },
+                                name: { prop: 'name' },
+                                associatedOrders: [
+                                    { root: null },
+                                    { prop: 'allOrders' },
+                                    {
+                                        'array.filter': {
+                                            equals: [
+                                                { prop: 'customerId' },
+                                                [{ root: null }, { prop: 'currentCustomer' }, { prop: 'id' }],
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+        result: [
+            {
+                id: 'customer1',
+                name: 'Customer 1',
+                associatedOrders: [
+                    { id: 'orderA', customerId: 'customer1', value: 'Order A for Customer 1' },
+                    { id: 'orderC', customerId: 'customer1', value: 'Order C for Customer 1' },
+                    { id: 'orderE', customerId: 'customer1', value: 'Order E for Customer 1' },
+                ],
+            },
+            {
+                id: 'customer2',
+                name: 'Customer 2',
+                associatedOrders: [
+                    { id: 'orderB', customerId: 'customer2', value: 'Order B for Customer 2' },
+                    { id: 'orderF', customerId: 'customer2', value: 'Order F for Customer 2' },
+                ],
+            },
+            {
+                id: 'customer3',
+                name: 'Customer 3',
+                associatedOrders: [
+                    { id: 'orderD', customerId: 'customer3', value: 'Order D for Customer 3' },
+                ],
+            },
+        ],
+    },
     maths: {
         input: { version: 0 },
         remapper: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/lang-sdk",
-  "version": "0.36.3-test.6",
+  "version": "0.36.4",
   "description": "Language SDK for Appsemble",
   "keywords": [
     "app",
@@ -39,21 +39,21 @@
     "test": "vitest"
   },
   "dependencies": {
-    "openapi-types": "^12.0.0",
     "@odata/parser": "^0.2.14",
+    "cron-parser": "^4.0.0",
     "date-fns": "^2.0.0",
+    "date-fns-tz": "^2.0.1",
     "fast-deep-equal": "^3.0.0",
+    "fast-xml-parser": "^5.0.8",
     "ics": "^3.0.0",
     "intl-messageformat": "^11.0.0",
-    "parse-duration": "^1.0.0",
-    "fast-xml-parser": "^5.0.8",
-    "vitest": "^2.0.0",
-    "cron-parser": "^4.0.0",
+    "jsonschema": "~1.4.1",
     "language-tags": "^1.0.0",
+    "lcm": "^0.0.3",
+    "openapi-types": "^12.0.0",
+    "parse-duration": "^1.0.0",
     "type-fest": "^4.0.0",
-    "jsonschema": "~1.4.1",
-    "yaml": "^2.0.0",
-    "lcm": "^0.0.3"
+    "yaml": "^2.0.0"
   },
   "devDependencies": {
     "@types/language-tags": "1.0.4",

package/reference-schemas/remappers/arrays.js

@@ -25,6 +25,21 @@ return the full object with the data we want in the \`then\` section. It’s als
 This results in an array consisting of \`null\` values and objects with actual data in them. To solve
 this problem, we use the \`null.strip\` remapper to remove any null values which results in a clean
 array.
+`,
+    },
+    'array.range': {
+        $ref: '#/components/schemas/RemapperDefinition',
+        description: `
+Creates an array of numbers from 0 to N-1, where N is the resolved value of the remapper.
+This is useful for creating a dynamically-sized array.
+
+If the resolved value is not a non-negative integer, an empty array is returned.
+
+${schemaExample('array.range')}
+
+It's particularly powerful when combined with \`array.map\` to generate a list of arbitrary elements.
+
+${schemaExample('array.range.map', { input: 'pretty' })}
 `,
     },
     'array.join': {
@@ -34,6 +49,41 @@ array.
     If the input is not an array, input is returned without any modifications.
 
     ${schemaExample('array.join')}
+`,
+    },
+    'array.groupBy': {
+        type: 'string',
+        description: `
+Groups an array of objects by a common property value.
+
+Returns an array of group objects, each containing a \`key\` (the grouped property value)
+and \`items\` (array of objects with that property value).
+
+If the input is not an array, returns an empty array.
+
+${schemaExample('array.groupBy')}
+
+The groups preserve the order of first occurrence of each key value.
+`,
+    },
+    'array.toObject': {
+        type: 'object',
+        additionalProperties: false,
+        required: ['key', 'value'],
+        properties: {
+            key: { $ref: '#/components/schemas/RemapperDefinition' },
+            value: { $ref: '#/components/schemas/RemapperDefinition' },
+        },
+        description: `
+Converts an array of objects into a single object using specified key and value remappers.
+
+For each item in the array, the \`key\` remapper determines the property name and the \`value\`
+remapper determines the property value in the resulting object.
+
+If the input is not an array, returns an empty object.
+If multiple items produce the same key, later items overwrite earlier ones.
+
+${schemaExample('array.toObject')}
 `,
     },
     'array.unique': {
@@ -300,6 +350,58 @@ ${schemaExample('array.flatten', { input: 'pretty', exclude: ['remapper'] })}
         description: `
 Checks if the input array includes the provided item.
 ${schemaExample('array.contains')}
+`,
+    },
+    'array.sort': {
+        oneOf: [
+            { type: 'string' },
+            {
+                type: 'object',
+                nullable: true,
+                additionalProperties: false,
+                properties: {
+                    by: { type: 'string' },
+                    descending: { type: 'boolean', default: false },
+                    strategy: {
+                        type: 'string',
+                        enum: ['infer', 'numeric', 'lexicographic', 'date'],
+                        default: 'infer',
+                    },
+                },
+            },
+        ],
+        description: `
+Sorts an array of items.
+
+Can sort by a property (for arrays of objects) or by the items themselves (for primitive arrays).
+Supports ascending and descending order, and handles numbers, strings, and dates.
+
+When a string is provided, it's used as the property name to sort by (ascending).
+
+**Sorting strategy (\`strategy\` option):**
+
+- \`infer\` (default): Determines comparison type from the first non-null value.
+  Numbers use numeric comparison, Dates use timestamp comparison, everything else
+  uses lexicographic (string) comparison. Mixed types fall back to lexicographic.
+- \`numeric\`: Coerces values to numbers. Non-numeric values (NaN) are pushed to the end.
+- \`lexicographic\`: Converts values to strings and uses \`localeCompare()\`.
+- \`date\`: Parses values as ISO dates and compares timestamps. Invalid dates are pushed to the end.
+
+Nullish values (null/undefined) are always pushed to the end regardless of strategy.
+
+${schemaExample('array.sort')}
+
+For arrays of objects, you can simply use a string to sort by that property:
+
+${schemaExample('array.sort.by')}
+
+Use \`descending: true\` to sort in descending order:
+
+${schemaExample('array.sort.desc')}
+
+Use \`strategy: numeric\` to force numeric comparison (useful for string numbers):
+
+${schemaExample('array.sort.numeric')}
 `,
     },
 };

package/reference-schemas/remappers/conditionals.js

@@ -55,6 +55,24 @@ Returns \`true\` if the first entry is greater than the second entry.
 For example, if \`stock\` is more than 5 here, it returns \`true\`.
 
 ${schemaExample('gt')}
+`,
+        minItems: 2,
+        maxItems: 2,
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+    },
+    gte: {
+        type: 'array',
+        description: `**(gte = Greater than or equal)**
+
+Compare the first computed remapper value with the second computed remapper value.
+
+Returns \`true\` if the first entry is greater than or equal to the second entry.
+
+For example, if \`stock\` is 5 or more here, it returns \`true\`.
+
+${schemaExample('gte')}
 `,
         minItems: 2,
         maxItems: 2,
@@ -64,15 +82,33 @@ ${schemaExample('gt')}
     },
     lt: {
         type: 'array',
-        description: `**(lt = Lesser than)
+        description: `**(lt = Less than)**
 
 Compare the first computed remapper value with the second computed remapper value.
 
-Returns \`true\` if the first entry is lesser than the second entry.
+Returns \`true\` if the first entry is less than the second entry.
 
 For example, if \`stock\` is less than 5 here, it returns \`true\`.
 
-${schemaExample('gt')}
+${schemaExample('lt')}
+`,
+        minItems: 2,
+        maxItems: 2,
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+    },
+    lte: {
+        type: 'array',
+        description: `**(lte = Less than or equal)**
+
+Compare the first computed remapper value with the second computed remapper value.
+
+Returns \`true\` if the first entry is less than or equal to the second entry.
+
+For example, if \`stock\` is 5 or less here, it returns \`true\`.
+
+${schemaExample('lte')}
 `,
         minItems: 2,
         maxItems: 2,

package/reference-schemas/remappers/data.js

@@ -410,5 +410,27 @@ ${schemaExample('slice')}`,
             { type: 'number' },
         ],
     },
+    focus: {
+        type: 'object',
+        description: `
+Executes a remapper chain with a temporary root context.
+
+This is useful for solving nested context problems, like performing a
+filter on one list that depends on a value from an outer loop.
+
+${schemaExample('focus', { input: 'pretty', result: 'pretty', exclude: [] })}
+`,
+        required: ['on', 'do'],
+        properties: {
+            on: {
+                description: 'The data to focus on. The input data will be remapped with this remapper, and the result will be passed as root context to `do`.',
+                $ref: '#/components/schemas/RemapperDefinition',
+            },
+            do: {
+                description: 'The remapper to execute with the focused data as root. The original input will be provided as input, and the result of `on` will be the root context.',
+                $ref: '#/components/schemas/RemapperDefinition',
+            },
+        },
+    },
 };
 //# sourceMappingURL=data.js.map

package/reference-schemas/remappers/dates.js

@@ -90,5 +90,52 @@ date.parse:
 \`\`\`
 `,
     },
+    'date.startOf': {
+        enum: ['year', 'quarter', 'month', 'week', 'weekSun'],
+        description: `Takes a date and returns the start of the specified unit.
+
+Supported units:
+- \`year\`: First day of the year
+- \`quarter\`: First day of the quarter
+- \`month\`: First day of the month
+- \`week\`: First day of the week (Monday)
+- \`weekSun\`: First day of the week (Sunday)
+
+${schemaExample('date.startOf')}
+`,
+    },
+    'date.endOf': {
+        enum: ['year', 'quarter', 'month', 'week', 'weekSun'],
+        description: `Takes a date and returns the end of the specified unit.
+
+Supported units:
+- \`year\`: Last moment of the year
+- \`quarter\`: Last moment of the quarter
+- \`month\`: Last moment of the month
+- \`week\`: Last moment of the week (ends Sunday if week starts Monday)
+- \`weekSun\`: Last moment of the week (ends Saturday if week starts Sunday)
+
+${schemaExample('date.endOf')}
+`,
+    },
+    'date.set': {
+        type: 'object',
+        description: `Sets parts of a date. Only the given parts are changed.
+
+Month is 1-indexed (1 = January, 12 = December).
+
+${schemaExample('date.set')}`,
+        properties: {
+            year: {
+                $ref: '#/components/schemas/RemapperDefinition',
+            },
+            month: {
+                $ref: '#/components/schemas/RemapperDefinition',
+            },
+            day: {
+                $ref: '#/components/schemas/RemapperDefinition',
+            },
+        },
+    },
 };
 //# sourceMappingURL=dates.js.map

package/remap.js

@@ -1,5 +1,6 @@
 import { filter, literalValues, param } from '@odata/parser';
-import { addMilliseconds, format, parse, parseISO } from 'date-fns';
+import { addMilliseconds, endOfMonth, endOfQuarter, endOfWeek, endOfYear, format, parse, parseISO, set as setDate, startOfMonth, startOfQuarter, startOfWeek, startOfYear, } from 'date-fns';
+import { utcToZonedTime, zonedTimeToUtc } from 'date-fns-tz';
 import equal from 'fast-deep-equal';
 import { XMLParser } from 'fast-xml-parser';
 import { createEvent } from 'ics';
@@ -66,6 +67,40 @@ export function remap(remapper, input, context) {
     }
     return result;
 }
+// Comparison functions for array.sort
+const compareNumeric = (aVal, bVal) => {
+    const aNum = Number(aVal);
+    const bNum = Number(bVal);
+    const aIsNaN = Number.isNaN(aNum);
+    const bIsNaN = Number.isNaN(bNum);
+    if (aIsNaN && bIsNaN) {
+        return 0;
+    }
+    if (aIsNaN) {
+        return 1;
+    }
+    if (bIsNaN) {
+        return -1;
+    }
+    return aNum - bNum;
+};
+const compareLexicographic = (aVal, bVal) => String(aVal).localeCompare(String(bVal));
+const compareDate = (aVal, bVal) => {
+    const aDate = aVal instanceof Date ? aVal : parseISO(String(aVal));
+    const bDate = bVal instanceof Date ? bVal : parseISO(String(bVal));
+    const aInvalid = Number.isNaN(aDate.getTime());
+    const bInvalid = Number.isNaN(bDate.getTime());
+    if (aInvalid && bInvalid) {
+        return 0;
+    }
+    if (aInvalid) {
+        return 1;
+    }
+    if (bInvalid) {
+        return -1;
+    }
+    return aDate.getTime() - bDate.getTime();
+};
 /**
  * Implementations of all remappers.
  *
@@ -150,10 +185,18 @@ const mapperImplementations = {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
     remap(left, input, context) > remap(right, input, context),
+    gte: ([left, right], input, context) => 
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
+    remap(left, input, context) >= remap(right, input, context),
     lt: ([left, right], input, context) => 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
     remap(left, input, context) < remap(right, input, context),
+    lte: ([left, right], input, context) => 
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
+    remap(left, input, context) <= remap(right, input, context),
     ics(mappers, input, context) {
         let event;
         const mappedStart = remap(mappers.start, input, context);
@@ -207,6 +250,10 @@ const mapperImplementations = {
         const condition = remap(mappers.condition, input, context);
         return remap(condition ? mappers.then : mappers.else, input, context);
     },
+    focus({ do: doRemapper, on }, input, context) {
+        const newRoot = remap(on, input, context);
+        return remap(doRemapper, input, { ...context, root: newRoot });
+    },
     match(mappers, input, context) {
         return (remap(mappers.find((mapper) => remap(mapper.case, input, context))?.value ?? null, input, context) ?? null);
     },
@@ -309,6 +356,13 @@ const mapperImplementations = {
             nextItem: input[index + 1],
         },
     })) ?? [],
+    'array.range'(countRemapper, input, context) {
+        const count = remap(countRemapper, input, context);
+        if (typeof count !== 'number' || !Number.isInteger(count) || count < 0) {
+            return [];
+        }
+        return Array.from({ length: count }, (item, idx) => idx);
+    },
     'array.contains'(mapper, input, context) {
         if (!Array.isArray(input)) {
             return false;
@@ -328,6 +382,92 @@ const mapperImplementations = {
         }
         return input.join(separator ?? undefined);
     },
+    'array.groupBy'(propertyName, input) {
+        if (!Array.isArray(input)) {
+            return [];
+        }
+        const groups = new Map();
+        for (const item of input) {
+            const key = item?.[propertyName];
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(item);
+        }
+        return [...groups.entries()].map(([key, items]) => ({ key, items }));
+    },
+    'array.toObject'({ key: keyMapper, value: valueMapper }, input, context) {
+        if (!Array.isArray(input)) {
+            return {};
+        }
+        const result = {};
+        for (const [index, item] of input.entries()) {
+            const itemContext = {
+                ...context,
+                array: {
+                    index,
+                    length: input.length,
+                    item,
+                    prevItem: input[index - 1],
+                    nextItem: input[index + 1],
+                },
+            };
+            const key = remap(keyMapper, item, itemContext);
+            const value = remap(valueMapper, item, itemContext);
+            if (key != null) {
+                result[String(key)] = value;
+            }
+        }
+        return result;
+    },
+    'array.sort'(mapper, input) {
+        if (!Array.isArray(input)) {
+            return input;
+        }
+        // Normalize mapper: string becomes { by: string }, null/undefined becomes {}
+        const { by, descending = false, strategy = 'infer', } = typeof mapper === 'string'
+            ? { by: mapper, descending: false, strategy: 'infer' }
+            : (mapper ?? {});
+        // Extract values for sorting
+        const getValue = (item) => by ? item?.[by] : item;
+        // Determine effective strategy for 'infer' mode
+        let effectiveStrategy = strategy;
+        if (strategy === 'infer') {
+            // Find first non-null value to determine type
+            const firstValue = input.map(getValue).find((v) => v != null);
+            if (typeof firstValue === 'number') {
+                effectiveStrategy = 'numeric';
+            }
+            else if (firstValue instanceof Date) {
+                effectiveStrategy = 'date';
+            }
+            else {
+                effectiveStrategy = 'lexicographic';
+            }
+        }
+        const compare = effectiveStrategy === 'numeric'
+            ? compareNumeric
+            : effectiveStrategy === 'date'
+                ? compareDate
+                : compareLexicographic;
+        const sorted = [...input].sort((a, b) => {
+            const aValue = getValue(a);
+            const bValue = getValue(b);
+            // Handle nullish values - push them to the end
+            if (aValue == null && bValue == null) {
+                return 0;
+            }
+            if (aValue == null) {
+                return 1;
+            }
+            if (bValue == null) {
+                return -1;
+            }
+            const comparison = compare(aValue, bValue);
+            return descending ? -comparison : comparison;
+        });
+        return sorted;
+    },
     'array.unique'(mapper, input, context) {
         if (!Array.isArray(input)) {
             return input;
@@ -494,6 +634,85 @@ const mapperImplementations = {
                 : parseISO(String(input));
         return args ? format(date, args) : date.toJSON();
     },
+    'date.startOf'(unit, input) {
+        const date = input instanceof Date
+            ? input
+            : typeof input === 'number'
+                ? new Date(input)
+                : parseISO(String(input));
+        let result;
+        switch (unit) {
+            case 'year':
+                result = startOfYear(date);
+                break;
+            case 'quarter':
+                result = startOfQuarter(date);
+                break;
+            case 'month':
+                result = startOfMonth(date);
+                break;
+            case 'week':
+                result = startOfWeek(date, { weekStartsOn: 1 });
+                break;
+            case 'weekSun':
+                result = startOfWeek(date, { weekStartsOn: 0 });
+                break;
+            default:
+                return input;
+        }
+        return result.toJSON();
+    },
+    'date.endOf'(unit, input) {
+        const date = input instanceof Date
+            ? input
+            : typeof input === 'number'
+                ? new Date(input)
+                : parseISO(String(input));
+        let result;
+        switch (unit) {
+            case 'year':
+                result = endOfYear(date);
+                break;
+            case 'quarter':
+                result = endOfQuarter(date);
+                break;
+            case 'month':
+                result = endOfMonth(date);
+                break;
+            case 'week':
+                result = endOfWeek(date, { weekStartsOn: 1 });
+                break;
+            case 'weekSun':
+                result = endOfWeek(date, { weekStartsOn: 0 });
+                break;
+            default:
+                return input;
+        }
+        return result.toJSON();
+    },
+    'date.set'(args, input, context) {
+        const date = input instanceof Date
+            ? input
+            : typeof input === 'number'
+                ? new Date(input)
+                : parseISO(String(input));
+        const remapped = mapValues(args, (mapper) => remap(mapper, input, context));
+        const setValues = {};
+        if (typeof remapped.year === 'number') {
+            setValues.year = remapped.year;
+        }
+        if (typeof remapped.month === 'number') {
+            // Convert from 1-indexed (user-facing) to 0-indexed (date-fns)
+            setValues.month = remapped.month - 1;
+        }
+        if (typeof remapped.day === 'number') {
+            setValues.date = remapped.day;
+        }
+        // Convert to UTC-zoned date so set operates in UTC
+        const zonedDate = utcToZonedTime(date, 'UTC');
+        const result = setDate(zonedDate, setValues);
+        return zonedTimeToUtc(result, 'UTC').toJSON();
+    },
     'null.strip': (args, input) => stripNullValues(input, args || {}),
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)

package/types/member.d.ts

@@ -70,4 +70,8 @@ export interface AppMemberInfo {
      * Unverified email of the user, this will replace the current email when verified.
      */
     unverifiedEmail?: string;
+    /**
+     * Whether TOTP (two-factor authentication) is enabled for this app member.
+     */
+    totpEnabled?: boolean;
 }

package/types/remapper.d.ts

@@ -141,6 +141,40 @@ export interface Remappers {
      * Please refer to https://date-fns.org/docs/format for the supported patterns.
      */
     'date.format'?: string;
+    /**
+     * Takes a date and returns the start of the specified unit.
+     *
+     * Supported units:
+     * - `year`: First day of the year
+     * - `quarter`: First day of the quarter
+     * - `month`: First day of the month
+     * - `week`: First day of the week (Monday)
+     * - `weekSun`: First day of the week (Sunday)
+     */
+    'date.startOf': 'month' | 'quarter' | 'week' | 'weekSun' | 'year';
+    /**
+     * Takes a date and returns the end of the specified unit.
+     *
+     * Supported units:
+     * - `year`: Last moment of the year
+     * - `quarter`: Last moment of the quarter
+     * - `month`: Last moment of the month
+     * - `week`: Last moment of the week (ends Sunday if week starts Monday)
+     * - `weekSun`: Last moment of the week (ends Saturday if week starts Sunday)
+     */
+    'date.endOf': 'month' | 'quarter' | 'week' | 'weekSun' | 'year';
+    /**
+     * Sets parts of a date.
+     *
+     * Only the given parts are changed.
+     *
+     * Month is 1-indexed (1 = January, 12 = December).
+     */
+    'date.set': {
+        year?: Remapper;
+        month?: Remapper;
+        day?: Remapper;
+    };
     /**
      * Compare all computed remapper values against each other.
      *
@@ -181,12 +215,24 @@ export interface Remappers {
      * Returns `true` of the first entry is greater than the second entry.
      */
     gt: [Remapper, Remapper];
+    /**
+     * Compares the first computed remapper value with the second computed remapper value.
+     *
+     * Returns `true` of the first entry is greater than or equal to the second entry.
+     */
+    gte: [Remapper, Remapper];
     /**
      * Compares the first computed remapper value with the second computed remapper value.
      *
      * Returns `true` of the first entry is less than the second entry.
      */
     lt: [Remapper, Remapper];
+    /**
+     * Compares the first computed remapper value with the second computed remapper value.
+     *
+     * Returns `true` of the first entry is less than or equal to the second entry.
+     */
+    lte: [Remapper, Remapper];
     /**
      * Logs its input data (returns it) and its context.
      *
@@ -205,6 +251,13 @@ export interface Remappers {
      * Always returns an array, can be empty if supplied data isn’t an array.
      */
     'array.map': Remapper;
+    /**
+     * Creates an array of numbers from 0 to N-1.
+     *
+     * @example
+     * { "array.range": 5 } // returns [0, 1, 2, 3, 4]
+     */
+    'array.range': Remapper;
     /**
      * Filters out unique entries from an array.
      *
@@ -438,6 +491,97 @@ export interface Remappers {
      *
      */
     'array.join': string | null;
+    /**
+     * Groups an array of objects by a common property value.
+     *
+     * Returns an array of group objects, each containing a `key` (the grouped property value)
+     * and `items` (array of objects with that property value).
+     *
+     * If the input is not an array, returns an empty array.
+     *
+     * @example
+     * // Input: [{ name: "Alice", dept: "Eng" }, { name: "Bob", dept: "Sales" }, { name: "Charlie", dept: "Eng" }]
+     * { "array.groupBy": "dept" }
+     * // Result: [
+     * //   { key: "Eng", items: [{ name: "Alice", dept: "Eng" }, { name: "Charlie", dept: "Eng" }] },
+     * //   { key: "Sales", items: [{ name: "Bob", dept: "Sales" }] }
+     * // ]
+     */
+    'array.groupBy': string;
+    /**
+     * Converts an array of objects into a single object using specified key and value remappers.
+     *
+     * For each item in the array, the `key` remapper determines the property name and the `value`
+     * remapper determines the property value in the resulting object.
+     *
+     * If the input is not an array, returns an empty object.
+     * If multiple items produce the same key, later items overwrite earlier ones.
+     *
+     * @example
+     * // Input: [{ key: "Eng", items: [...] }, { key: "Sales", items: [...] }]
+     * { "array.toObject": { key: { prop: "key" }, value: { prop: "items" } } }
+     * // Result: { "Eng": [...], "Sales": [...] }
+     */
+    'array.toObject': {
+        key: Remapper;
+        value: Remapper;
+    };
+    /**
+     * Sorts an array of items.
+     *
+     * Can sort by a property (for arrays of objects) or by the items themselves (for primitive arrays).
+     * Supports ascending and descending order, and handles numbers, strings, and dates.
+     *
+     * When a string is provided, it's used as the property name to sort by (ascending).
+     *
+     * **Sorting strategy (`strategy` option):**
+     *
+     * - `infer` (default): Determines comparison type from the first non-null value.
+     * Numbers use numeric comparison, Dates use timestamp comparison, everything else
+     * uses lexicographic (string) comparison. Mixed types fall back to lexicographic.
+     * - `numeric`: Coerces values to numbers. Non-numeric values (NaN) are pushed to the end.
+     * - `lexicographic`: Converts values to strings and uses `localeCompare()`.
+     * - `date`: Parses values as ISO dates and compares timestamps. Invalid dates are pushed to the end.
+     *
+     * Nullish values (null/undefined) are always pushed to the end regardless of strategy.
+     *
+     * @example
+     * // Input: [3, 1, 2]
+     * { "array.sort": null }
+     * // Result: [1, 2, 3]
+     * @example
+     * // Input: [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }]
+     * { "array.sort": "name" }
+     * // Result: [{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }]
+     * @example
+     * // Input: [{ name: "Charlie" }, { name: "Alice" }, { name: "Bob" }]
+     * { "array.sort": { by: "name", descending: true } }
+     * // Result: [{ name: "Charlie" }, { name: "Bob" }, { name: "Alice" }]
+     * @example
+     * // Input: ["10", "2", "1"]
+     * { "array.sort": { strategy: "numeric" } }
+     * // Result: ["1", "2", "10"]
+     */
+    'array.sort': string | {
+        /**
+         * The property name to sort by. If not provided, sorts by the items themselves.
+         */
+        by?: string;
+        /**
+         * Whether to sort in descending order. Defaults to false (ascending).
+         */
+        descending?: boolean;
+        /**
+         * The comparison strategy to use.
+         *
+         * - `infer` (default): Auto-detect from first non-null value. Numbers use numeric,
+         * Dates use date, others use lexicographic. Mixed types fall back to lexicographic.
+         * - `numeric`: Coerce to numbers. NaN values pushed to end.
+         * - `lexicographic`: Convert to strings, use localeCompare().
+         * - `date`: Parse as ISO dates, compare timestamps. Invalid dates pushed to end.
+         */
+        strategy?: 'date' | 'infer' | 'lexicographic' | 'numeric';
+    } | null;
     /**
      * This remapper return true if the provided string is a substring of the input string.
      *
@@ -593,6 +737,59 @@ export interface Remappers {
         b: Remapper;
         operation: 'add' | 'divide' | 'mod' | 'multiply' | 'subtract';
     };
+    /**
+     * Executes a remapper chain with a temporary root context.
+     *
+     * This is useful for solving nested context problems, like performing a
+     * filter on one list that depends on a value from an outer loop.
+     *
+     * @example
+     *
+     * // Get all customers, and for each customer, find the orders belonging to that customer.
+     * // Assumes that `history: 1` is an array of all customers,
+     * // and `history: 2` is an array of all orders.
+     * {
+     *   'array.map': {
+     *     focus: {
+     *       on: {
+     *         'object.from': {
+     *           currentCustomer: { array: 'item' },
+     *           allOrders: { history: 1 },
+     *         },
+     *       },
+     *       do: {
+     *         'object.from': {
+     *           id: { prop: 'id' },
+     *           name: { prop: 'name' },
+     *           associatedOrders: [
+     *             { root: null },
+     *             { prop: 'allOrders' },
+     *             {
+     *               'array.filter': {
+     *                 equals: [
+     *                   { prop: 'customerId' },
+     *                   [{ root: null }, { prop: 'currentCustomer' }, { prop: 'id' }],
+     *                 ],
+     *               },
+     *             },
+     *           ],
+     *         },
+     *       },
+     *     },
+     *   },
+     * },
+     */
+    focus: {
+        /**
+         * A remapper that resolves to the object that will become the new `root`
+         * for the `do` remapper chain.
+         */
+        on: Remapper;
+        /**
+         * The remapper or chain of remappers to execute with the new focused `root`.
+         */
+        do: Remapper;
+    };
 }
 export type ObjectRemapper = RequireExactlyOne<Remappers>;
 export type ArrayRemapper = (ArrayRemapper | ObjectRemapper)[];