@todoist/sdk 0.0.1 → 18.0.0

package/dist/esm/types/workspaces/types.js

@@ -0,0 +1,151 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { z } from 'zod';
+import { StringOrNumberSchema } from '../common.js';
+import { DueDateSchema, DeadlineSchema } from '../tasks/types.js';
+/** Available project collaborator roles. */
+export const COLLABORATOR_ROLES = [
+    'CREATOR',
+    'ADMIN',
+    'READ_WRITE',
+    'EDIT_ONLY',
+    'COMPLETE_ONLY',
+];
+/**
+ * Available workspace roles.
+ */
+export const WORKSPACE_ROLES = ['ADMIN', 'MEMBER', 'GUEST'];
+export const WorkspaceRoleSchema = z.enum(WORKSPACE_ROLES);
+export const WorkspaceUserSchema = z.object({
+    userId: z.string(),
+    workspaceId: z.string(),
+    userEmail: z.string(),
+    fullName: z.string(),
+    timezone: z.string(),
+    role: WorkspaceRoleSchema,
+    imageId: z.string().nullable(),
+    isDeleted: z.boolean().default(false),
+});
+export const WorkspaceInvitationSchema = z.object({
+    id: z.string().default('0'),
+    inviterId: z.string(),
+    userEmail: z.string(),
+    workspaceId: z.string(),
+    role: WorkspaceRoleSchema,
+});
+export const PlanPriceSchema = z.object({
+    currency: z.string(),
+    amount: z.union([z.number(), z.string()]),
+    interval: z.string().optional(),
+});
+export const FormattedPriceListingSchema = z.object({
+    currency: z.string().optional(),
+    amount: z.number().optional(),
+    interval: z.string().optional(),
+    formatted: z.string().optional(),
+});
+/** Available workspace plan names. */
+export const WORKSPACE_CURRENT_PLANS = ['Business', 'Starter'];
+/** Available workspace plan statuses. */
+export const WORKSPACE_PLAN_STATUSES = [
+    'Active',
+    'Downgraded',
+    'Cancelled',
+    'NeverSubscribed',
+];
+export const WorkspacePlanDetailsSchema = z.object({
+    currentMemberCount: z.number(),
+    currentPlan: z.enum(WORKSPACE_CURRENT_PLANS),
+    currentPlanStatus: z.enum(WORKSPACE_PLAN_STATUSES),
+    downgradeAt: z.string().nullable(),
+    currentActiveProjects: z.number(),
+    maximumActiveProjects: z.number(),
+    priceList: z.array(FormattedPriceListingSchema),
+    workspaceId: StringOrNumberSchema,
+    isTrialing: z.boolean(),
+    trialEndsAt: z.string().nullable(),
+    cancelAtPeriodEnd: z.boolean(),
+    hasTrialed: z.boolean(),
+    planPrice: PlanPriceSchema.nullable(),
+    hasBillingPortal: z.boolean(),
+    hasBillingPortalSwitchToAnnual: z.boolean(),
+});
+export const JoinWorkspaceResultSchema = z.object({
+    customSortingApplied: z.boolean(),
+    projectSortPreference: z.string(),
+    role: WorkspaceRoleSchema,
+    userId: z.string(),
+    workspaceId: z.string(),
+});
+/**
+ * Available workspace plans.
+ */
+export const WORKSPACE_PLANS = ['STARTER', 'BUSINESS'];
+export const WorkspacePlanSchema = z.enum(WORKSPACE_PLANS);
+/**
+ * Workspace resource limits.
+ */
+export const WorkspaceLimitsSchema = z
+    .object({
+    current: z.record(z.string(), z.any()).nullable(),
+    next: z.record(z.string(), z.any()).nullable(),
+})
+    .catchall(z.any());
+/**
+ * Workspace properties (flexible object for unknown fields).
+ */
+export const WorkspacePropertiesSchema = z.record(z.string(), z.unknown());
+/**
+ * Represents a workspace in Todoist.
+ */
+export const WorkspaceSchema = z
+    .object({
+    id: StringOrNumberSchema,
+    name: z.string(),
+    plan: WorkspacePlanSchema,
+    role: WorkspaceRoleSchema.optional(),
+    inviteCode: z.string(),
+    isLinkSharingEnabled: z.boolean(),
+    isGuestAllowed: z.boolean(),
+    limits: WorkspaceLimitsSchema.optional(),
+    logoBig: z.string().nullish(),
+    logoMedium: z.string().nullish(),
+    logoSmall: z.string().nullish(),
+    logoS640: z.string().nullish(),
+    createdAt: z.coerce.date().optional(),
+    dateCreated: z.coerce.date().optional(),
+    creatorId: StringOrNumberSchema,
+    properties: WorkspacePropertiesSchema,
+})
+    .transform((_a) => {
+    var { dateCreated, createdAt } = _a, rest = __rest(_a, ["dateCreated", "createdAt"]);
+    return (Object.assign(Object.assign({}, rest), { createdAt: createdAt !== null && createdAt !== void 0 ? createdAt : dateCreated }));
+});
+export const MemberActivityInfoSchema = z.object({
+    userId: z.string(),
+    tasksAssigned: z.number().int(),
+    tasksOverdue: z.number().int(),
+});
+export const WorkspaceUserTaskSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    responsibleUid: z.string().nullable(),
+    due: DueDateSchema.nullable(),
+    deadline: DeadlineSchema.nullable(),
+    labels: z.array(z.string()),
+    notesCount: z.number().int(),
+    projectId: z.string(),
+    projectName: z.string(),
+    priority: z.number().int(),
+    description: z.string(),
+    isOverdue: z.boolean(),
+});

package/dist/esm/utils/activity-helpers.js

@@ -0,0 +1,53 @@
+/**
+ * Converts modern SDK object type naming to legacy API naming.
+ * Maps 'task' -> 'item' and 'comment' -> 'note' for API requests.
+ * Other values pass through unchanged.
+ *
+ * @internal
+ * @param objectType The object type using modern naming.
+ * @returns The object type using legacy API naming.
+ */
+export function normalizeObjectTypeForApi(objectType) {
+    if (!objectType)
+        return objectType;
+    if (objectType === 'task')
+        return 'item';
+    if (objectType === 'comment')
+        return 'note';
+    return objectType;
+}
+/**
+ * Converts legacy API object type naming to modern SDK naming.
+ * Maps 'item' -> 'task' and 'note' -> 'comment' for SDK responses.
+ * Other values pass through unchanged.
+ *
+ * @internal
+ * @param objectType The object type using legacy API naming.
+ * @returns The object type using modern SDK naming.
+ */
+export function denormalizeObjectTypeFromApi(objectType) {
+    if (!objectType)
+        return objectType;
+    if (objectType === 'item')
+        return 'task';
+    if (objectType === 'note')
+        return 'comment';
+    return objectType;
+}
+/**
+ * Normalizes an `ActivityObjectEventType` filter string for the API,
+ * converting modern object type names to legacy API names.
+ * e.g. 'task:added' -> 'item:added', 'comment:' -> 'note:', ':deleted' -> ':deleted'
+ *
+ * @internal
+ */
+export function normalizeObjectEventTypeForApi(filter) {
+    var _a, _b;
+    const colonIndex = filter.indexOf(':');
+    if (colonIndex === -1) {
+        return (_a = normalizeObjectTypeForApi(filter)) !== null && _a !== void 0 ? _a : filter;
+    }
+    const objectPart = filter.slice(0, colonIndex);
+    const eventPart = filter.slice(colonIndex); // includes the colon
+    return `${(_b = normalizeObjectTypeForApi(objectPart)) !== null && _b !== void 0 ? _b : objectPart}${eventPart}`;
+}

package/dist/esm/utils/case-conversion.js

@@ -0,0 +1,84 @@
+import camelcase from 'camelcase';
+import emojiRegex from 'emoji-regex';
+/**
+ * Checks if a string is a solitary emoji
+ */
+function isEmojiKey(input) {
+    const regex = emojiRegex();
+    const match = input.match(regex);
+    return match !== null && match.join('') === input;
+}
+/**
+ * Custom camelCase function that preserves emoji strings
+ */
+export function customCamelCase(input) {
+    // If the value is a solitary emoji string, return the key as-is
+    if (isEmojiKey(input)) {
+        return input;
+    }
+    return camelcase(input);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && value.constructor === Object;
+}
+/**
+ * Fields, by their API name, whose value crosses case conversion untouched in both
+ * directions; only the field name itself is converted. View options' `property_settings`
+ * is keyed by opaque property IDs (`field:6Jf8VQXx`) and keeps attributes the SDK doesn't
+ * know, which can hold IDs of their own, so no key inside it is safe to rename.
+ */
+const VERBATIM_FIELDS = new Set(['property_settings']);
+/**
+ * Converts object keys from snake_case to camelCase recursively
+ *
+ * @param obj - The value to convert.
+ * @param options.opaqueKeyMaps - Top-level fields whose value is a map keyed by
+ * identifiers rather than field names, such as the Sync API's `sync_status`
+ * (keyed by command UUID). Those identifiers are kept exactly as received, since
+ * camel-casing would rewrite them; the map's values are still converted.
+ */
+export function camelCaseKeys(obj, { opaqueKeyMaps } = {}) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => camelCaseKeys(item));
+    }
+    if (isPlainObject(obj)) {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const camelKey = customCamelCase(key);
+            if (VERBATIM_FIELDS.has(key)) {
+                converted[camelKey] = value;
+                continue;
+            }
+            converted[camelKey] =
+                (opaqueKeyMaps === null || opaqueKeyMaps === void 0 ? void 0 : opaqueKeyMaps.has(key)) && isPlainObject(value)
+                    ? Object.fromEntries(Object.entries(value).map(([id, entry]) => [id, camelCaseKeys(entry)]))
+                    : camelCaseKeys(value);
+        }
+        return converted;
+    }
+    return obj;
+}
+/**
+ * Converts object keys from camelCase to snake_case recursively
+ */
+export function snakeCaseKeys(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => snakeCaseKeys(item));
+    }
+    if (typeof obj === 'object' && obj.constructor === Object) {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // Convert camelCase to snake_case
+            const snakeKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+            converted[snakeKey] = VERBATIM_FIELDS.has(snakeKey) ? value : snakeCaseKeys(value);
+        }
+        return converted;
+    }
+    return obj;
+}

package/dist/esm/utils/colors.js

@@ -0,0 +1,145 @@
+import { colorForDisplay } from '@doist/sdk-kmp/shared-todoist-all';
+export const berryRed = {
+    key: 'berry_red',
+    displayName: 'Berry Red',
+    hexValue: '#b8255f',
+};
+export const red = {
+    key: 'red',
+    displayName: 'Red',
+    hexValue: '#db4035',
+};
+export const orange = {
+    key: 'orange',
+    displayName: 'Orange',
+    hexValue: '#ff9933',
+};
+export const yellow = {
+    key: 'yellow',
+    displayName: 'Yellow',
+    hexValue: '#fad000',
+};
+export const oliveGreen = {
+    key: 'olive_green',
+    displayName: 'Olive Green',
+    hexValue: '#afb83b',
+};
+export const limeGreen = {
+    key: 'lime_green',
+    displayName: 'Lime Green',
+    hexValue: '#7ecc49',
+};
+export const green = {
+    key: 'green',
+    displayName: 'Green',
+    hexValue: '#299438',
+};
+export const mintGreen = {
+    key: 'mint_green',
+    displayName: 'Mint Green',
+    hexValue: '#6accbc',
+};
+export const teal = {
+    key: 'teal',
+    displayName: 'Teal',
+    hexValue: '#158fad',
+};
+export const skyBlue = {
+    key: 'sky_blue',
+    displayName: 'Sky Blue',
+    hexValue: '#14aaf5',
+};
+export const lightBlue = {
+    key: 'light_blue',
+    displayName: 'Light Blue',
+    hexValue: '#96c3eb',
+};
+export const blue = {
+    key: 'blue',
+    displayName: 'Blue',
+    hexValue: '#4073ff',
+};
+export const grape = {
+    key: 'grape',
+    displayName: 'Grape',
+    hexValue: '#884dff',
+};
+export const violet = {
+    key: 'violet',
+    displayName: 'Violet',
+    hexValue: '#af38eb',
+};
+export const lavender = {
+    key: 'lavender',
+    displayName: 'Lavender',
+    hexValue: '#eb96eb',
+};
+export const magenta = {
+    key: 'magenta',
+    displayName: 'Magenta',
+    hexValue: '#e05194',
+};
+export const salmon = {
+    key: 'salmon',
+    displayName: 'Salmon',
+    hexValue: '#ff8d85',
+};
+export const charcoal = {
+    key: 'charcoal',
+    displayName: 'Charcoal',
+    hexValue: '#808080',
+};
+export const grey = {
+    key: 'grey',
+    displayName: 'Grey',
+    hexValue: '#b8b8b8',
+};
+export const taupe = {
+    key: 'taupe',
+    displayName: 'Taupe',
+    hexValue: '#ccac93',
+};
+/**
+ * Every color, in the order the apps show them. The keys mirror `TodoistColor` from
+ * `@doist/sdk-kmp/shared-todoist-all`; the display names and hex values are the SDK's own.
+ */
+export const colors = [
+    berryRed,
+    red,
+    orange,
+    yellow,
+    oliveGreen,
+    limeGreen,
+    green,
+    mintGreen,
+    teal,
+    skyBlue,
+    lightBlue,
+    blue,
+    grape,
+    violet,
+    lavender,
+    magenta,
+    salmon,
+    charcoal,
+    grey,
+    taupe,
+];
+export const defaultColor = charcoal;
+/**
+ * Retrieves a {@link Color} object by its key identifier.
+ *
+ * @param colorKey - The unique key identifier of the color to find (e.g., 'berry_red', 'sky_blue')
+ * @returns The matching Color object if found, otherwise returns the default color (charcoal)
+ *
+ * @example
+ * ```typescript
+ * const color = getColorByKey('berry_red');
+ * console.log(color.hexValue); // '#b8255f'
+ * ```
+ */
+export function getColorByKey(colorKey) {
+    var _a;
+    const { key } = colorForDisplay(colorKey);
+    return (_a = colors.find((color) => color.key === key)) !== null && _a !== void 0 ? _a : defaultColor;
+}

package/dist/esm/utils/file-response.js

@@ -0,0 +1,29 @@
+import { headersToRecord } from './headers.js';
+/**
+ * Wraps either a native `Response` or a `CustomFetchResponse` into the SDK's
+ * `FileResponse` shape (binary endpoints: `viewAttachment`, `downloadBackup`).
+ *
+ * `arrayBuffer()` is resolved lazily. A customFetch implementation that omits
+ * `arrayBuffer()` is still valid for callers that only read `text()`/`json()`;
+ * the descriptive error is thrown only if the caller actually requests binary
+ * bytes. This avoids the lossy `text()` → `TextEncoder` round-trip that
+ * corrupts non-UTF-8 bytes (every `0x80`-`0xFF` byte not part of a valid UTF-8
+ * sequence is replaced with `U+FFFD`).
+ */
+export function wrapAsFileResponse(response, context) {
+    const headers = response.headers instanceof Headers ? headersToRecord(response.headers) : response.headers;
+    return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        text: () => response.text(),
+        json: () => response.json(),
+        arrayBuffer: () => {
+            if (typeof response.arrayBuffer !== 'function') {
+                throw new Error(`customFetch response must implement arrayBuffer() for ${context} (binary endpoint); reading the body via text() corrupts non-UTF-8 bytes`);
+            }
+            return response.arrayBuffer();
+        },
+    };
+}

package/dist/esm/utils/filter-queries.js

@@ -0,0 +1,231 @@
+import { FILTER_QUERY_DATE_TOKENS, FILTER_QUERY_LANGUAGES, FILTER_QUERY_OPERATOR_TOKENS, FILTER_QUERY_PATTERNS, FILTER_QUERY_TOKENS, } from './filter-query-definitions.js';
+const DEFAULT_LANGUAGE = 'en';
+const DATE_TOKENS = new Set(FILTER_QUERY_DATE_TOKENS);
+const OPERATOR_TOKENS = new Set(FILTER_QUERY_OPERATOR_TOKENS);
+/** Operators are the same symbols in every language, and they end a bare date. */
+const OPERATOR_PATTERN = /[()!&|]/;
+/**
+ * Deepest run of parentheses this reads before giving up.
+ *
+ * Parentheses are the only construct left that recurses, and Todoist caps a
+ * saved query long before this. The limit is what keeps a hostile string from
+ * reaching the call stack.
+ */
+const MAX_NESTING_DEPTH = 100;
+/** Codes the parser answers to beyond the language names themselves. */
+const LANGUAGE_ALIASES = new Map([
+    ['zh-cn', 'zh_cn'],
+    ['zh-hans', 'zh_cn'],
+    ['zh_hans', 'zh_cn'],
+    ['zh-tw', 'zh_tw'],
+    ['zh-hant', 'zh_tw'],
+    ['zh_hant', 'zh_tw'],
+]);
+const MATCHERS_BY_LANGUAGE = new Map();
+function lookUpLanguage(code) {
+    var _a;
+    return ((_a = LANGUAGE_ALIASES.get(code)) !== null && _a !== void 0 ? _a : FILTER_QUERY_LANGUAGES.find((language) => language === code));
+}
+function resolveLanguage(lang) {
+    var _a, _b;
+    if (!lang)
+        return DEFAULT_LANGUAGE;
+    const code = lang.toLowerCase();
+    return (_b = (_a = lookUpLanguage(code)) !== null && _a !== void 0 ? _a : lookUpLanguage(code.split(/[-_]/)[0])) !== null && _b !== void 0 ? _b : DEFAULT_LANGUAGE;
+}
+function createMatchers(language) {
+    const patterns = FILTER_QUERY_PATTERNS[language];
+    const matchers = [];
+    for (const token of FILTER_QUERY_TOKENS) {
+        for (const pattern of patterns[token]) {
+            matchers.push({
+                token,
+                length: pattern.length,
+                regex: new RegExp(`\\s*${pattern}\\s*`, 'iuy'),
+            });
+        }
+    }
+    // Longest pattern first, as the engine does. Otherwise `all` claims the
+    // front of Dutch's `alles bekijken` and the rest reads as a date.
+    return matchers.sort((a, b) => b.length - a.length);
+}
+function matchersFor(language) {
+    const cached = MATCHERS_BY_LANGUAGE.get(language);
+    if (cached)
+        return cached;
+    const matchers = createMatchers(language);
+    MATCHERS_BY_LANGUAGE.set(language, matchers);
+    return matchers;
+}
+function matchAt(query, cursor, matchers) {
+    for (const matcher of matchers) {
+        matcher.regex.lastIndex = cursor;
+        if (matcher.regex.test(query) && matcher.regex.lastIndex > cursor) {
+            return { token: matcher.token, end: matcher.regex.lastIndex };
+        }
+    }
+    return null;
+}
+/**
+ * Splits a query on unescaped commas, the way Todoist does before parsing.
+ * Each part is drawn as its own list.
+ */
+function splitSubqueries(query) {
+    const subqueries = [];
+    let current = '';
+    let escaped = false;
+    for (let index = 0; index < query.length; index += 1) {
+        const character = query[index];
+        if (character === ',' && !escaped) {
+            subqueries.push(current);
+            current = '';
+            continue;
+        }
+        current += character;
+        escaped = !escaped && character === '\\';
+    }
+    subqueries.push(current);
+    return subqueries.map((subquery) => subquery.trim()).filter((subquery) => subquery.length > 0);
+}
+/**
+ * Reads a subquery into tokens.
+ *
+ * Anything the vocabulary doesn't claim is a bare date: the engine tries every
+ * keyword first and hands what is left to its date parser, which is what reads
+ * `today`, `hoy` and `2026-12-24`. A bare date runs to the next operator.
+ */
+function tokenize(subquery, matchers) {
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < subquery.length) {
+        const match = matchAt(subquery, cursor, matchers);
+        if (match) {
+            tokens.push(match.token);
+            cursor = match.end;
+            continue;
+        }
+        const offset = subquery.slice(cursor + 1).search(OPERATOR_PATTERN);
+        tokens.push('BARE_DATE');
+        cursor = offset === -1 ? subquery.length : cursor + 1 + offset;
+    }
+    return tokens;
+}
+function peek(reader) {
+    return reader.index < reader.tokens.length ? reader.tokens[reader.index] : undefined;
+}
+function next(reader) {
+    const token = peek(reader);
+    reader.index += 1;
+    return token;
+}
+/**
+ * `<expression 4> ::= <expression 3> [ or <expression 4> ]`
+ *
+ * The engine nests this to the right and folds with a minimum, so reading the
+ * chain in a loop lands on the same grouping without a frame per operator.
+ */
+function readOr(reader) {
+    let grouping = readAnd(reader);
+    while (grouping !== null && peek(reader) === 'OR') {
+        next(reader);
+        const right = readAnd(reader);
+        if (right === null)
+            return null;
+        // `|` keeps the lower grouping, so one flat side flattens the pair.
+        grouping = grouping === 'DAY' && right === 'DAY' ? 'DAY' : 'FLAT';
+    }
+    return grouping;
+}
+/** `<expression 3> ::= <expression 2> [ and <expression 3> ]` */
+function readAnd(reader) {
+    let grouping = readNot(reader);
+    while (grouping !== null && peek(reader) === 'AND') {
+        next(reader);
+        const right = readNot(reader);
+        if (right === null)
+            return null;
+        // `&` keeps the higher grouping, so one dated side leads the pair.
+        grouping = grouping === 'DAY' || right === 'DAY' ? 'DAY' : 'FLAT';
+    }
+    return grouping;
+}
+/** `<expression 2> ::= { [ not ] <expression 2> } | <expression 1>` */
+function readNot(reader) {
+    let negated = false;
+    while (peek(reader) === 'NOT') {
+        next(reader);
+        negated = true;
+    }
+    const grouping = readOperand(reader);
+    if (grouping === null)
+        return null;
+    // A negation never groups by day, however the expression under it reads.
+    return negated ? 'FLAT' : grouping;
+}
+/** `<expression 1> ::= { "(" <expression> ")" } | <query>` */
+function readOperand(reader) {
+    const token = next(reader);
+    if (token === undefined)
+        return null;
+    if (token === 'LEFT') {
+        if (reader.depth >= MAX_NESTING_DEPTH)
+            return null;
+        reader.depth += 1;
+        const grouping = readOr(reader);
+        reader.depth -= 1;
+        if (grouping === null || next(reader) !== 'RIGHT')
+            return null;
+        return grouping;
+    }
+    if (token === 'BARE_DATE')
+        return 'DAY';
+    if (OPERATOR_TOKENS.has(token))
+        return null;
+    return DATE_TOKENS.has(token) ? 'DAY' : 'FLAT';
+}
+function groupingOf(subquery, matchers) {
+    const reader = { tokens: tokenize(subquery, matchers), index: 0, depth: 0 };
+    const grouping = readOr(reader);
+    // Tokens left over mean the query doesn't parse, which the engine rejects.
+    return grouping !== null && reader.index === reader.tokens.length ? grouping : null;
+}
+/**
+ * Returns whether a filter query leads with dates rather than with priority.
+ *
+ * Todoist gives every filter one of two default hierarchies, and a query that
+ * mentions dates gets the date-first one. Pass the answer to {@link sortTasks}
+ * as its `defaultOrder`:
+ *
+ * ```ts
+ * sortTasks(tasks, {
+ *     sortedBy: savedOptions?.sortedBy,
+ *     sortOrder: savedOptions?.sortOrder,
+ *     defaultOrder: isDateDrivenQuery(query, { lang }) ? 'DATE_FIRST' : 'PRIORITY_FIRST',
+ * })
+ * ```
+ *
+ * The query is read in `lang`, the account language `getUser` returns, the way
+ * the API reads it. English keywords parse under every language, so `lang` only
+ * matters for a query written in the account's own: `sin fecha` is a keyword
+ * under `es` and an unreadable phrase under `en`.
+ *
+ * Commas divide a filter into subqueries and Todoist draws each one as its own
+ * list, with its own hierarchy. Classify them one at a time for exact results;
+ * a whole query answers true only when every subquery is date-driven.
+ *
+ * Two kinds of unreadable query part company here. One that breaks the grammar,
+ * such as `(today`, returns false. One that only breaks the vocabulary, such as
+ * `sin fecha` under `en`, returns true, because a word this package doesn't
+ * recognize is treated as a bare date. Pass the account's own `lang` and the
+ * question doesn't arise; get it wrong and a keyword can read as a date.
+ *
+ * The function performs no I/O.
+ *
+ * @see sortTasks
+ */
+export function isDateDrivenQuery(query, options = {}) {
+    const matchers = matchersFor(resolveLanguage(options.lang));
+    const subqueries = splitSubqueries(query);
+    return (subqueries.length > 0 &&
+        subqueries.every((subquery) => groupingOf(subquery, matchers) === 'DAY'));
+}