@doist/todoist-sdk 14.0.2 → 14.2.0

package/dist/esm/utils/multipart-upload.js

@@ -1,3 +1,24 @@
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { v4 as uuidv4 } from 'uuid';
 import { fetchWithRetry } from '../transport/fetch-with-retry.js';
 import { camelCaseKeys } from './case-conversion.js';
 /**
@@ -23,6 +44,116 @@ function getContentTypeFromFileName(fileName) {
             return 'application/octet-stream';
     }
 }
+/**
+ * Escapes a value for use inside a quoted `Content-Disposition` parameter,
+ * where a raw quote would end the value early and a raw CR or LF would end the
+ * header. Note that a lone CR needs escaping too, not just CRLF pairs.
+ *
+ * This is the same escaping the platform's own `FormData` encoder applies, so
+ * servers see exactly what they would from any browser or from undici.
+ */
+function escapeDispositionValue(value) {
+    return value.replace(/"/g, '%22').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+}
+/**
+ * Lays out a `multipart/form-data` payload around a single file part, as the
+ * text that goes before and after the file content. Keeping the file content
+ * out of it lets the same layout serve both a `Blob` body and a streamed one.
+ */
+function layOutMultipart(args) {
+    const { fileName, fileContentType, additionalFields } = args;
+    const boundary = `----todoist-sdk-${uuidv4()}`;
+    const head = `--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="file"; filename="${escapeDispositionValue(fileName)}"\r\n` +
+        `Content-Type: ${fileContentType}\r\n\r\n`;
+    let tail = '\r\n';
+    for (const [key, value] of Object.entries(additionalFields)) {
+        if (value !== undefined && value !== null) {
+            tail +=
+                `--${boundary}\r\n` +
+                    `Content-Disposition: form-data; name="${escapeDispositionValue(key)}"\r\n\r\n` +
+                    `${value.toString()}\r\n`;
+        }
+    }
+    tail += `--${boundary}--\r\n`;
+    return { boundary, head, tail };
+}
+/**
+ * Wraps a Node readable stream as a `multipart/form-data` request body.
+ *
+ * The result is a web `ReadableStream`, which both the runtime's `fetch` and
+ * undici's own accept — unlike a Node stream or a `FormData`, either of which
+ * only works with one particular client. The file is never buffered, so the
+ * request is sent with `Transfer-Encoding: chunked`.
+ */
+function streamMultipartBody(file, parts) {
+    const encoder = new TextEncoder();
+    function chunks() {
+        return __asyncGenerator(this, arguments, function* chunks_1() {
+            var _a, e_1, _b, _c;
+            yield yield __await(encoder.encode(parts.head));
+            try {
+                for (var _d = true, file_1 = __asyncValues(file), file_1_1; file_1_1 = yield __await(file_1.next()), _a = file_1_1.done, !_a; _d = true) {
+                    _c = file_1_1.value;
+                    _d = false;
+                    const chunk = _c;
+                    yield yield __await(typeof chunk === 'string' ? encoder.encode(chunk) : new Uint8Array(chunk));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = file_1.return)) yield __await(_b.call(file_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            yield yield __await(encoder.encode(parts.tail));
+        });
+    }
+    const iterator = chunks();
+    // Driven by hand rather than with `ReadableStream.from`, which is absent
+    // from this project's DOM lib types and is still missing in some browsers,
+    // or `Readable.toWeb`, which would drag a Node-only import into a module
+    // that browsers also load.
+    return new ReadableStream({
+        async pull(controller) {
+            const { value, done } = await iterator.next();
+            if (done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(value);
+        },
+        async cancel(reason) {
+            var _a;
+            await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator, reason));
+        },
+    });
+}
+/**
+ * Builds the request body for a multipart upload.
+ *
+ * Deliberately avoids `FormData`. A `FormData` body is only encoded by the
+ * `fetch` that owns that `FormData` class — undici brands its own — so a body
+ * built from the global `FormData` and sent through undici's `fetch`, or the
+ * reverse, is stringified to the literal `"[object FormData]"` and the upload
+ * silently carries no file. The `form-data` package fares worse: neither
+ * `fetch` accepts it as a body at all. `Blob` and `ReadableStream` carry no
+ * such brand and work with whichever `fetch` dispatches the request,
+ * including a caller-supplied `customFetch`.
+ */
+function buildMultipartBody(args) {
+    const { file, fileName, fileContentType, additionalFields } = args;
+    const parts = layOutMultipart({ fileName, fileContentType, additionalFields });
+    const contentType = `multipart/form-data; boundary=${parts.boundary}`;
+    if (file instanceof Blob) {
+        // A Blob keeps its length, so the request gets a Content-Length and
+        // stays replayable if it has to be retried. File-backed Blobs (from
+        // `fs.openAsBlob`) stay lazy here, so nothing is read into memory.
+        return { body: new Blob([parts.head, file, parts.tail]), contentType, isStreamed: false };
+    }
+    return { body: streamMultipartBody(file, parts), contentType, isStreamed: true };
+}
 /**
  * Uploads a file using multipart/form-data.
  *
@@ -75,69 +206,52 @@ export async function uploadMultipartFile(args) {
     if (requestId) {
         headers['X-Request-Id'] = requestId;
     }
+    // Resolve the file to something every `fetch` accepts as a body part: a
+    // Blob where the size is known up front, or a Node stream that gets piped
+    // through untouched.
+    let filePart;
+    let resolvedFileName;
     if (file instanceof Blob) {
-        // Browser path: use native FormData
-        const form = new globalThis.FormData();
-        const resolvedFileName = fileName || (file instanceof File ? file.name : undefined) || 'upload';
-        form.append('file', file, resolvedFileName);
-        for (const [key, value] of Object.entries(additionalFields)) {
-            if (value !== undefined && value !== null) {
-                form.append(key, value.toString());
-            }
+        filePart = file;
+        resolvedFileName = fileName || (file instanceof File ? file.name : undefined) || 'upload';
+    }
+    else if (typeof file === 'string') {
+        // File path: Node-only, so import lazily to keep browser bundles clean.
+        const [fsModule, pathModule] = await Promise.all([import('fs'), import('path')]);
+        resolvedFileName = fileName || pathModule.basename(file);
+        // `openAsBlob` reads the file lazily, so a large upload is not pulled
+        // into memory, and the resulting body still has a known length.
+        filePart = await fsModule.openAsBlob(file);
+    }
+    else if (Buffer.isBuffer(file)) {
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a Buffer');
         }
-        // Don't set Content-Type — let fetch set it with the correct multipart boundary
-        body = form;
+        resolvedFileName = fileName;
+        filePart = new Blob([
+            new Uint8Array(file.buffer, file.byteOffset, file.byteLength),
+        ]);
     }
     else {
-        // Node path: dynamically import Node-only modules
-        const [FormDataModule, fsModule, pathModule] = await Promise.all([
-            import('form-data'),
-            import('fs'),
-            import('path'),
-        ]);
-        const FormData = FormDataModule.default;
-        const form = new FormData();
-        if (typeof file === 'string') {
-            // File path - create read stream
-            const resolvedFileName = fileName || pathModule.basename(file);
-            form.append('file', fsModule.createReadStream(file), resolvedFileName);
-        }
-        else if (Buffer.isBuffer(file)) {
-            // Buffer - require fileName
-            if (!fileName) {
-                throw new Error('fileName is required when uploading from a Buffer');
-            }
-            const contentType = getContentTypeFromFileName(fileName);
-            form.append('file', file, {
-                filename: fileName,
-                contentType: contentType,
-            });
-        }
-        else {
-            // Stream - require fileName
-            if (!fileName) {
-                throw new Error('fileName is required when uploading from a stream');
-            }
-            form.append('file', file, fileName);
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a stream');
         }
-        for (const [key, value] of Object.entries(additionalFields)) {
-            if (value !== undefined && value !== null) {
-                form.append(key, value.toString());
-            }
-        }
-        Object.assign(headers, form.getHeaders());
-        body = form;
+        resolvedFileName = fileName;
+        filePart = file;
     }
-    // Make the request using fetch
-    const response = await fetchWithRetry({
-        url,
-        options: {
-            method: 'POST',
-            body,
-            headers,
-            timeout: 30000, // 30 second timeout for file uploads
-        },
-        customFetch,
+    const multipart = buildMultipartBody({
+        file: filePart,
+        fileName: resolvedFileName,
+        fileContentType: (filePart instanceof Blob ? filePart.type : undefined) ||
+            getContentTypeFromFileName(resolvedFileName),
+        additionalFields,
     });
+    // The boundary is ours, so Content-Type has to be set explicitly — `fetch`
+    // only fills it in for a `FormData` body.
+    headers['Content-Type'] = multipart.contentType;
+    body = multipart.body;
+    // Make the request using fetch
+    const response = await fetchWithRetry(Object.assign(Object.assign({ url, options: Object.assign({ method: 'POST', body,
+            headers, timeout: 30000 }, (multipart.isStreamed ? { duplex: 'half' } : {})) }, (multipart.isStreamed ? { retryConfig: { retries: 0 } } : {})), { customFetch }));
     return camelCaseKeys(response.data);
 }

package/dist/esm/utils/task-sorting.js

@@ -0,0 +1,277 @@
+/** Todoist's default task-ordering hierarchies. */
+export const DEFAULT_TASK_ORDERS = ['PRIORITY_FIRST', 'DATE_FIRST'];
+const DEFAULT_TIMEZONE = 'UTC';
+const DEFAULT_LOCALE = 'en';
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DATE_TIME_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/;
+const EXPLICIT_TIMEZONE_PATTERN = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+const DATE_TIME_FORMATTERS = new Map();
+function compareNumber(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+function isValidDateParts(year, month, day) {
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month - 1, day);
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function dateSortValue({ year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0, isAllDay = false, }) {
+    if (!isValidDateParts(year, month, day) ||
+        hour < 0 ||
+        hour > 23 ||
+        minute < 0 ||
+        minute > 59 ||
+        second < 0 ||
+        second > 59 ||
+        millisecond < 0 ||
+        millisecond > 999) {
+        return null;
+    }
+    return {
+        day: year * 10000 + month * 100 + day,
+        kind: isAllDay ? 0 : 1,
+        time: ((hour * 60 + minute) * 60 + second) * 1000 + millisecond,
+    };
+}
+function parseDateOnly(value) {
+    const match = DATE_ONLY_PATTERN.exec(value);
+    if (!match)
+        return null;
+    return dateSortValue({
+        year: Number(match[1]),
+        month: Number(match[2]),
+        day: Number(match[3]),
+        isAllDay: true,
+    });
+}
+function parseDateTimeComponents(value) {
+    var _a, _b;
+    const match = DATE_TIME_PATTERN.exec(value);
+    if (!match)
+        return null;
+    const milliseconds = Number(((_a = match[7]) !== null && _a !== void 0 ? _a : '').padEnd(3, '0').slice(0, 3));
+    const components = {
+        year: Number(match[1]),
+        month: Number(match[2]),
+        day: Number(match[3]),
+        hour: Number(match[4]),
+        minute: Number(match[5]),
+        second: Number((_b = match[6]) !== null && _b !== void 0 ? _b : 0),
+        millisecond: milliseconds,
+    };
+    return dateSortValue(components) === null ? null : components;
+}
+function createDateTimeFormatter(timezone, fallback) {
+    const cached = DATE_TIME_FORMATTERS.get(timezone);
+    if (cached)
+        return cached;
+    try {
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            calendar: 'iso8601',
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hourCycle: 'h23',
+        });
+        DATE_TIME_FORMATTERS.set(timezone, formatter);
+        return formatter;
+    }
+    catch (_a) {
+        return fallback !== null && fallback !== void 0 ? fallback : createDateTimeFormatter(DEFAULT_TIMEZONE);
+    }
+}
+function componentsAt(timestamp, formatter) {
+    const parts = formatter.formatToParts(new Date(timestamp));
+    function part(type) {
+        var _a;
+        return Number((_a = parts.find((entry) => entry.type === type)) === null || _a === void 0 ? void 0 : _a.value);
+    }
+    return {
+        year: part('year'),
+        month: part('month'),
+        day: part('day'),
+        hour: part('hour'),
+        minute: part('minute'),
+        second: part('second'),
+        millisecond: new Date(timestamp).getUTCMilliseconds(),
+    };
+}
+function componentsAsUtcTimestamp({ year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0, }) {
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, millisecond);
+    return date.getTime();
+}
+/** Resolves a zoned wall clock to an instant, including daylight-saving offsets. */
+function timestampForWallClock(components, formatter) {
+    const target = componentsAsUtcTimestamp(components);
+    let timestamp = target;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const adjustment = target - componentsAsUtcTimestamp(componentsAt(timestamp, formatter));
+        if (adjustment === 0)
+            return timestamp;
+        timestamp += adjustment;
+    }
+    return null;
+}
+function dateSortValueAt(timestamp, formatter) {
+    const value = dateSortValue(componentsAt(timestamp, formatter));
+    return value ? Object.assign(Object.assign({}, value), { time: timestamp }) : null;
+}
+function parseFixedDateTime(value, formatter) {
+    if (parseDateTimeComponents(value.replace(EXPLICIT_TIMEZONE_PATTERN, '')) === null)
+        return null;
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? null : dateSortValueAt(timestamp, formatter);
+}
+function parseZonedFloatingDateTime(value, sourceFormatter, accountFormatter) {
+    const components = parseDateTimeComponents(value);
+    if (!components)
+        return null;
+    const timestamp = timestampForWallClock(components, sourceFormatter);
+    return timestamp === null ? null : dateSortValueAt(timestamp, accountFormatter);
+}
+function parseTaskDate(value, formatter, timezone) {
+    var _a;
+    return ((_a = parseDateOnly(value)) !== null && _a !== void 0 ? _a : (EXPLICIT_TIMEZONE_PATTERN.test(value)
+        ? parseFixedDateTime(value, formatter)
+        : parseZonedFloatingDateTime(value, timezone ? createDateTimeFormatter(timezone, formatter) : formatter, formatter)));
+}
+function compareNullable(a, b, compare) {
+    if (a === null || b === null) {
+        if (a === b)
+            return 0;
+        return a === null ? 1 : -1;
+    }
+    return compare(a, b);
+}
+function compareDateValues(left, right) {
+    return (compareNumber(left.day, right.day) ||
+        compareNumber(left.kind, right.kind) ||
+        compareNumber(left.time, right.time));
+}
+function compareDate(a, b) {
+    return compareNullable(a, b, compareDateValues);
+}
+function compareOptionalNumber(a, b) {
+    return compareNullable(a, b, compareNumber);
+}
+function compareOptionalText(a, b, collator) {
+    return compareNullable(a, b, (left, right) => collator.compare(left, right));
+}
+function prepareTasks(tasks, context, { formatter, resolveAssignee }) {
+    return tasks.map((task, index) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const due = task.due
+            ? parseTaskDate((_a = task.due.datetime) !== null && _a !== void 0 ? _a : task.due.date, formatter, task.due.timezone)
+            : null;
+        const deadline = task.deadline ? parseTaskDate(task.deadline.date, formatter) : null;
+        return {
+            task,
+            index,
+            due,
+            deadline,
+            schedule: due !== null && due !== void 0 ? due : deadline,
+            added: task.addedAt && !Number.isNaN(task.addedAt.getTime())
+                ? task.addedAt.getTime()
+                : null,
+            project: (_c = (_b = context.projectOrder) === null || _b === void 0 ? void 0 : _b.get(task.projectId)) !== null && _c !== void 0 ? _c : null,
+            workspace: (_e = (_d = context.workspaceOrder) === null || _d === void 0 ? void 0 : _d.get(task.projectId)) !== null && _e !== void 0 ? _e : null,
+            assignee: resolveAssignee ? ((_g = (_f = context.assigneeName) === null || _f === void 0 ? void 0 : _f.call(context, task)) !== null && _g !== void 0 ? _g : null) : null,
+        };
+    });
+}
+function comparePriorityFirst(a, b) {
+    const common = compareNumber(b.task.priority, a.task.priority) ||
+        compareDate(a.due, b.due) ||
+        compareDate(a.deadline, b.deadline);
+    if (common !== 0)
+        return common;
+    const project = compareOptionalNumber(a.project, b.project);
+    if (project !== 0)
+        return project;
+    if (a.task.projectId === b.task.projectId) {
+        return compareNumber(a.task.childOrder, b.task.childOrder);
+    }
+    return 0;
+}
+function compareDateFirst(a, b) {
+    return (compareDate(a.schedule, b.schedule) ||
+        compareNumber(b.task.priority, a.task.priority) ||
+        compareDate(a.deadline, b.deadline) ||
+        compareNumber(a.task.dayOrder, b.task.dayOrder) ||
+        compareOptionalNumber(a.added, b.added));
+}
+function compareDefault(a, b, defaultOrder) {
+    return defaultOrder === 'DATE_FIRST' ? compareDateFirst(a, b) : comparePriorityFirst(a, b);
+}
+function comparePrimary({ sortedBy, a, b, collator, }) {
+    switch (sortedBy) {
+        case 'ALPHABETICALLY':
+            return collator.compare(a.task.content, b.task.content);
+        case 'ASSIGNEE':
+            return compareOptionalText(a.assignee, b.assignee, collator);
+        case 'DUE_DATE':
+            return compareDate(a.due, b.due);
+        case 'DEADLINE':
+            return compareDate(a.deadline, b.deadline);
+        case 'ADDED_DATE':
+            return compareOptionalNumber(a.added, b.added);
+        case 'PRIORITY':
+            return compareNumber(a.task.priority, b.task.priority);
+        case 'PROJECT':
+            return compareOptionalNumber(a.project, b.project);
+        case 'WORKSPACE':
+            return compareOptionalNumber(a.workspace, b.workspace);
+        case 'MANUAL':
+            return 0;
+    }
+}
+function defaultSortOrder(sortedBy) {
+    return sortedBy === 'PRIORITY' ? 'DESC' : 'ASC';
+}
+/**
+ * Sorts the supplied tasks using Todoist view-ordering rules.
+ *
+ * The function performs no I/O and always returns a new array. Exact project,
+ * workspace, assignee, localized text, and due-time ordering requires the
+ * corresponding context. Callers must sort each independent view section or
+ * group separately and preserve any subtask structure they render.
+ *
+ * This function sorts only the tasks supplied to it. Fetch every page first
+ * when globally correct ordering is required for a paginated query.
+ */
+export function sortTasks(tasks, options, context = {}) {
+    var _a, _b, _c;
+    const locale = Array.isArray(context.locale)
+        ? [...context.locale]
+        : ((_a = context.locale) !== null && _a !== void 0 ? _a : DEFAULT_LOCALE);
+    const collator = new Intl.Collator(locale, { sensitivity: 'base', numeric: true });
+    const formatter = createDateTimeFormatter((_b = context.timezone) !== null && _b !== void 0 ? _b : DEFAULT_TIMEZONE);
+    const sortedBy = options.sortedBy;
+    const prepared = prepareTasks(tasks, context, {
+        formatter,
+        resolveAssignee: sortedBy === 'ASSIGNEE',
+    });
+    const direction = sortedBy && sortedBy !== 'MANUAL' ? ((_c = options.sortOrder) !== null && _c !== void 0 ? _c : defaultSortOrder(sortedBy)) : null;
+    const directionMultiplier = direction === 'DESC' ? -1 : 1;
+    return prepared
+        .sort((a, b) => {
+        if (sortedBy && sortedBy !== 'MANUAL') {
+            const primary = comparePrimary({ sortedBy, a, b, collator }) * directionMultiplier;
+            if (primary !== 0)
+                return primary;
+        }
+        return compareDefault(a, b, options.defaultOrder) || compareNumber(a.index, b.index);
+    })
+        .map(({ task }) => task);
+}

package/dist/esm/utils/view-options.js

@@ -0,0 +1,15 @@
+/** Returns whether saved view options are active rather than a deletion tombstone. */
+export function isActiveViewOption(options) {
+    return options.isDeleted !== true;
+}
+/** Finds the active saved options for one logical view. */
+export function findViewOptions(options, args) {
+    var _a;
+    const targetObjectId = (_a = args.objectId) !== null && _a !== void 0 ? _a : null;
+    return options.find((entry) => {
+        var _a;
+        return isActiveViewOption(entry) &&
+            ((_a = entry.objectId) !== null && _a !== void 0 ? _a : null) === targetObjectId &&
+            args.viewTypes.includes(entry.viewType);
+    });
+}

package/dist/types/clients/view-options-client.d.ts

@@ -0,0 +1,8 @@
+import type { ViewOptions, ViewOptionsDeleteArgs, ViewOptionsSetArgs } from '../types/sync/index.js';
+import { BaseClient } from './base-client.js';
+/** Internal sub-client for saved view-option reads and writes. */
+export declare class ViewOptionsClient extends BaseClient {
+    getViewOptions(): Promise<ViewOptions[]>;
+    setViewOptions(args: ViewOptionsSetArgs, requestId?: string): Promise<void>;
+    deleteViewOptions(args: ViewOptionsDeleteArgs, requestId?: string): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -2,4 +2,5 @@ export * from './todoist-api.js';
 export * from './authentication.js';
 export * from './types/index.js';
 export * from './utils/index.js';
-export { getDefaultDispatcher } from './transport/http-dispatcher.js';
+export { getDefaultDispatcher, getDefaultTransport } from './transport/http-dispatcher.js';
+export type { DefaultTransport } from './transport/http-dispatcher.js';

package/dist/types/todoist-api.d.ts

@@ -14,6 +14,7 @@ import { ProductivityStats } from './types/productivity/index.js';
 import { PersonalProject, WorkspaceProject, AddProjectArgs, UpdateProjectArgs, GetProjectsArgs, SearchProjectsArgs, GetProjectCollaboratorsArgs, GetProjectsResponse, GetProjectCollaboratorsResponse, GetArchivedProjectsArgs, GetArchivedProjectsResponse, MoveProjectToWorkspaceArgs, MoveProjectToPersonalArgs, GetArchivedProjectsCountArgs, GetArchivedProjectsCountResponse, GetProjectPermissionsResponse, GetFullProjectArgs, GetFullProjectResponse, JoinProjectResponse } from './types/projects/index.js';
 import { AddReminderArgs, UpdateReminderArgs, AddLocationReminderArgs, UpdateLocationReminderArgs, GetRemindersArgs, GetRemindersResponse, GetLocationRemindersArgs, GetLocationRemindersResponse } from './types/reminders/index.js';
 import { Section, AddSectionArgs, UpdateSectionArgs, GetSectionsArgs, SearchSectionsArgs, GetSectionsResponse } from './types/sections/index.js';
+import type { SyncRequest, SyncResponse, ViewOptions, ViewOptionsDeleteArgs, ViewOptionsSetArgs } from './types/sync/index.js';
 import type { Folder } from './types/sync/resources/folders.js';
 import { Task, AddTaskArgs, GetTasksArgs, GetTasksByFilterArgs, UpdateTaskArgs, QuickAddTaskArgs, type MoveTaskArgs, GetCompletedTasksByCompletionDateArgs, GetCompletedTasksByDueDateArgs, GetCompletedTasksResponse, SearchCompletedTasksArgs, GetTasksResponse, GetAllCompletedTasksArgs, GetAllCompletedTasksResponse } from './types/tasks/index.js';
 import { ExportTemplateFileArgs, ExportTemplateUrlArgs, ExportTemplateUrlResponse, CreateProjectFromTemplateArgs, CreateProjectFromTemplateResponse, ImportTemplateIntoProjectArgs, ImportTemplateFromIdArgs, ImportTemplateResponse } from './types/templates/index.js';
@@ -21,7 +22,6 @@ import type { AddUiExtensionArgs, UiExtension, UpdateUiExtensionArgs, UploadUiEx
 import { UploadFileArgs, DeleteUploadArgs } from './types/uploads/index.js';
 import { CurrentUser } from './types/users/index.js';
 import { WorkspaceInvitation, WorkspacePlanDetails, JoinWorkspaceResult, Workspace, AddWorkspaceArgs, UpdateWorkspaceArgs, GetWorkspaceMembersActivityArgs, GetWorkspaceMembersActivityResponse, GetWorkspaceUserTasksArgs, GetWorkspaceUserTasksResponse, InviteWorkspaceUsersArgs, InviteWorkspaceUsersResponse, UpdateWorkspaceUserArgs, RemoveWorkspaceUserArgs, GetWorkspaceInvitationsArgs, DeleteWorkspaceInvitationArgs, WorkspaceInvitationActionArgs, JoinWorkspaceArgs, WorkspaceLogoArgs, GetWorkspacePlanDetailsArgs, GetWorkspaceUsersArgs, GetWorkspaceUsersResponse, GetWorkspaceProjectsArgs, WorkspaceInvitationsResponse, AllWorkspaceInvitationsResponse, WorkspaceLogoResponse } from './types/workspaces/index.js';
-import { type SyncResponse, type SyncRequest } from './types/sync/index.js';
 /**
  * A client for interacting with the Todoist API v1.
  * This class provides methods to manage tasks, projects, sections, labels, and comments in Todoist.
@@ -79,6 +79,7 @@ export declare class TodoistApi {
     private readonly billingClient;
     private readonly appClient;
     private readonly uiExtensionClient;
+    private readonly viewOptionsClient;
     constructor(
     /**
      * Your Todoist API token.
@@ -113,6 +114,28 @@ export declare class TodoistApi {
      * ```
      */
     sync(syncRequest: SyncRequest, requestId?: string): Promise<SyncResponse>;
+    /**
+     * Retrieves the authenticated user's active saved view options.
+     *
+     * @returns A promise that resolves to the active saved view options.
+     */
+    getViewOptions(): Promise<ViewOptions[]>;
+    /**
+     * Sets saved options for a view.
+     *
+     * @param args - The saved view options to set.
+     * @param requestId - Optional custom identifier for the request.
+     * @returns A promise that resolves when the view options are saved.
+     */
+    setViewOptions(args: ViewOptionsSetArgs, requestId?: string): Promise<void>;
+    /**
+     * Deletes the saved options for a view.
+     *
+     * @param args - The view whose saved options to delete.
+     * @param requestId - Optional custom identifier for the request.
+     * @returns A promise that resolves when the view options are deleted.
+     */
+    deleteViewOptions(args: ViewOptionsDeleteArgs, requestId?: string): Promise<void>;
     /**
      * Retrieves information about the authenticated user.
      *

package/dist/types/transport/http-dispatcher.d.ts

@@ -7,7 +7,7 @@ type UndiciFetch = typeof import('undici').fetch;
  * never observe a dispatcher paired with a mismatched `fetch` — see
  * {@link getDefaultFetch} for why the pairing matters.
  */
-type DefaultTransport = {
+export type DefaultTransport = {
     dispatcher: Dispatcher;
     fetch: UndiciFetch | undefined;
 };
@@ -15,8 +15,33 @@ type DefaultTransport = {
  * The default dispatcher and its paired `fetch`, as a single value so the two
  * are always read consistently. Resolves to `undefined` outside Node (browser/
  * edge), where callers use the global `fetch` with no dispatcher.
+ *
+ * Use this when supplying a `customFetch` that should still honour the proxy
+ * environment variables (`HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`) and decode
+ * compressed responses the way the SDK does by default.
+ *
+ * Both halves must be used together. `dispatcher` decompresses the response
+ * body itself, so a `fetch` from a different undici build will try to decode
+ * it a second time and the request fails mid-stream with `terminated`. A
+ * `fetch` of `undefined` means the runtime's global `fetch` is the correct
+ * partner for this dispatcher.
+ *
+ * @example
+ * ```ts
+ * const transport = await getDefaultTransport()
+ * const fetchImpl = transport?.fetch ?? fetch
+ * const response = await fetchImpl(url, { ...options, dispatcher: transport?.dispatcher })
+ * ```
  */
 export declare function getDefaultTransport(): Promise<DefaultTransport | undefined>;
+/**
+ * The default dispatcher on its own.
+ *
+ * @deprecated Use {@link getDefaultTransport} instead, which returns this
+ * dispatcher together with the `fetch` it must be used with. Attaching this
+ * dispatcher to the runtime's global `fetch` decodes compressed responses
+ * twice on Node 26 and the request fails with `terminated`.
+ */
 export declare function getDefaultDispatcher(): Promise<Dispatcher | undefined>;
 /**
  * The `fetch` implementation that must be used with the default dispatcher.

package/dist/types/types/sync/commands/project-view-options.d.ts

@@ -1,7 +1,4 @@
-import type { ViewMode, GroupedBy, SortedBy, SortOrder, CalendarLayout } from '../resources/view-options.js';
-export type CalendarSettings = {
-    layout?: CalendarLayout;
-};
+import type { CalendarSettings, ViewMode, GroupedBy, SortedBy, SortOrder } from '../resources/view-options.js';
 export type ProjectViewOptionsDefaultsSetArgs = {
     projectId: string;
     viewMode?: ViewMode | null;