@dinoxx/dinox-cli 1.0.11 → 1.0.13

package/dist/commands/todo/taskModel.js

@@ -0,0 +1,349 @@
+const DEFAULT_TASK_TIME_DISPLAY_FORMAT = 'datetime';
+export function buildTaskKey(noteId, taskId) {
+    return `${noteId}:${taskId}`;
+}
+export function extractFlattenedTasks(rows) {
+    const extracted = [];
+    for (const row of rows) {
+        const noteId = normalizeString(row.id);
+        if (!noteId) {
+            continue;
+        }
+        const taskItems = parseImageDetailTaskItems(row.image_detail);
+        if (taskItems.length === 0) {
+            continue;
+        }
+        const { createdAt, createdAtRaw } = parseCreatedAt(row.created_at, row.updated_at);
+        extracted.push(...extractTasksFromDetailWithHierarchy({
+            noteId,
+            noteTitle: normalizeString(row.title),
+            createdAt,
+            createdAtRaw,
+            noteTags: parseNoteTags(row.tags),
+            taskItems,
+        }));
+    }
+    extracted.sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime());
+    return flattenTasks(extracted);
+}
+export function filterTasksForTodoList(allTasks, query, taskStatus, taskTagFilter, taskDateRange) {
+    let filteredTasks = allTasks;
+    const normalizedQuery = query.trim().toLocaleLowerCase();
+    if (normalizedQuery) {
+        filteredTasks = filteredTasks.filter((task) => task.text.toLocaleLowerCase().includes(normalizedQuery));
+    }
+    if (taskStatus === 'completed') {
+        filteredTasks = filteredTasks.filter((task) => task.checked);
+    }
+    else if (taskStatus === 'uncompleted') {
+        filteredTasks = filteredTasks.filter((task) => !task.checked);
+    }
+    if (taskTagFilter.length > 0) {
+        filteredTasks = filteredTasks.filter((task) => taskTagFilter.every((tag) => task.tags?.some((taskTag) => taskTag.trim() === tag)));
+    }
+    const range = resolveTaskDateRange(taskDateRange);
+    if (range) {
+        filteredTasks = filteredTasks.filter((task) => isTaskInDateRange(task, range));
+    }
+    return filteredTasks;
+}
+function parseImageDetailTaskItems(raw) {
+    if (Array.isArray(raw)) {
+        return pickTaskItems(raw);
+    }
+    if (typeof raw !== 'string') {
+        return [];
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return pickTaskItems(parsed);
+    }
+    catch {
+        return [];
+    }
+}
+function pickTaskItems(values) {
+    const result = [];
+    for (const value of values) {
+        if (!value || typeof value !== 'object') {
+            continue;
+        }
+        const node = value;
+        if (node.type !== 'taskItem') {
+            continue;
+        }
+        result.push(node);
+    }
+    return result;
+}
+function parseCreatedAt(createdAtRaw, updatedAtRaw) {
+    const createdAtValue = normalizeString(createdAtRaw) || null;
+    const fallback = normalizeString(updatedAtRaw) || null;
+    const source = createdAtValue ?? fallback;
+    if (!source) {
+        return { createdAt: new Date(0), createdAtRaw: createdAtValue };
+    }
+    const parsed = new Date(source);
+    if (Number.isNaN(parsed.getTime())) {
+        return { createdAt: new Date(0), createdAtRaw: createdAtValue };
+    }
+    return { createdAt: parsed, createdAtRaw: createdAtValue };
+}
+function parseNoteTags(raw) {
+    const value = normalizeString(raw);
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return undefined;
+        }
+        const tags = uniqueTrimmedStrings(parsed);
+        return tags.length > 0 ? tags : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniqueTrimmedStrings(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = normalizeString(String(value));
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function normalizeTaskTimeDisplayFormat(value) {
+    if (value === 'date')
+        return 'date';
+    if (value === 'datetime')
+        return 'datetime';
+    if (value === 'datetime-seconds')
+        return 'datetime-seconds';
+    if (value === 'time')
+        return 'time';
+    return DEFAULT_TASK_TIME_DISPLAY_FORMAT;
+}
+function getTaskText(node) {
+    if (!node || typeof node !== 'object')
+        return '';
+    const taskNode = node;
+    if (typeof taskNode.text === 'string') {
+        return (taskNode.text ?? '').trim();
+    }
+    if (taskNode.type === 'taskList') {
+        return '';
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return '';
+    }
+    return taskNode.content.map((child) => getTaskText(child)).join('');
+}
+function getTaskTags(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const taskNode = node;
+    if (taskNode.type === 'hashtag') {
+        const label = normalizeString(taskNode.attrs?.label);
+        return label ? [label] : [];
+    }
+    if (taskNode.type === 'taskList') {
+        return [];
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return [];
+    }
+    return taskNode.content.flatMap((child) => getTaskTags(child));
+}
+function collectTaskTimeNodes(node, out) {
+    if (!node || typeof node !== 'object' || out.length >= 2) {
+        return;
+    }
+    const taskNode = node;
+    if (taskNode.type === 'taskList') {
+        return;
+    }
+    if (taskNode.type === 'time' || taskNode.type === 'timeblock') {
+        const iso = normalizeString(taskNode.attrs?.iso);
+        if (iso) {
+            out.push({
+                iso,
+                displayFormat: normalizeTaskTimeDisplayFormat(taskNode.attrs?.displayFormat),
+            });
+            if (out.length >= 2) {
+                return;
+            }
+        }
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return;
+    }
+    for (const child of taskNode.content) {
+        collectTaskTimeNodes(child, out);
+        if (out.length >= 2) {
+            return;
+        }
+    }
+}
+function getTaskTimeRange(node) {
+    const points = [];
+    collectTaskTimeNodes(node, points);
+    if (points.length === 0) {
+        return {};
+    }
+    if (points.length === 1) {
+        return { dueTime: points[0] };
+    }
+    return {
+        startTime: points[0],
+        dueTime: points[1],
+    };
+}
+function extractNestedTasks(content) {
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const nested = [];
+    for (const value of content) {
+        if (!value || typeof value !== 'object') {
+            continue;
+        }
+        const node = value;
+        if (node.type === 'taskList' && Array.isArray(node.content)) {
+            nested.push(...pickTaskItems(node.content));
+            continue;
+        }
+        if (node.type === 'taskItem') {
+            nested.push(node);
+        }
+    }
+    return nested;
+}
+function extractTasksFromDetailWithHierarchy(input) {
+    const { noteId, noteTitle, createdAt, createdAtRaw, noteTags, taskItems, depth = 0 } = input;
+    const result = [];
+    for (const item of taskItems) {
+        const taskId = normalizeString(item.id) ||
+            normalizeString(item.attrs?.id) ||
+            '';
+        if (!taskId) {
+            continue;
+        }
+        const checked = item.checked === true || item.checked === 'true' || item.attrs?.checked === true;
+        const text = getTaskText(item).trim();
+        const tags = getTaskTags(item);
+        const { startTime, dueTime } = getTaskTimeRange(item);
+        const children = extractTasksFromDetailWithHierarchy({
+            noteId,
+            noteTitle,
+            createdAt,
+            createdAtRaw,
+            noteTags,
+            taskItems: extractNestedTasks(item.content),
+            depth: depth + 1,
+        });
+        result.push({
+            noteId,
+            noteTitle,
+            taskId,
+            text,
+            checked,
+            createdAt,
+            createdAtRaw,
+            startTime,
+            dueTime,
+            tags: tags.length > 0 ? tags : undefined,
+            noteTags,
+            children,
+            depth,
+        });
+    }
+    return result;
+}
+function flattenTasks(tasks, parentId = null) {
+    const result = [];
+    for (const task of tasks) {
+        result.push({
+            noteId: task.noteId,
+            noteTitle: task.noteTitle,
+            taskId: task.taskId,
+            text: task.text,
+            checked: task.checked,
+            createdAt: task.createdAt,
+            createdAtRaw: task.createdAtRaw,
+            startTime: task.startTime,
+            dueTime: task.dueTime,
+            tags: task.tags,
+            noteTags: task.noteTags,
+            depth: task.depth,
+            hasChildren: task.children.length > 0,
+            parentId,
+        });
+        if (task.children.length > 0) {
+            result.push(...flattenTasks(task.children, task.taskId));
+        }
+    }
+    return result;
+}
+function resolveTaskDateRange(taskDateRange) {
+    if (!taskDateRange) {
+        return null;
+    }
+    const startSource = taskDateRange.startDate ?? taskDateRange.endDate;
+    const endSource = taskDateRange.endDate ?? taskDateRange.startDate;
+    if (!startSource || !endSource) {
+        return null;
+    }
+    const start = new Date(startSource);
+    const end = new Date(endSource);
+    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+        return null;
+    }
+    start.setHours(0, 0, 0, 0);
+    end.setHours(23, 59, 59, 999);
+    return {
+        startMs: Math.min(start.getTime(), end.getTime()),
+        endMs: Math.max(start.getTime(), end.getTime()),
+    };
+}
+function isTaskInDateRange(task, range) {
+    const dueMs = parseTaskPointMs(task.dueTime);
+    if (dueMs !== null && dueMs >= range.startMs && dueMs <= range.endMs) {
+        return true;
+    }
+    const startMs = parseTaskPointMs(task.startTime);
+    if (startMs !== null && startMs >= range.startMs && startMs <= range.endMs) {
+        return true;
+    }
+    const createdAtMs = task.createdAt.getTime();
+    if (!Number.isNaN(createdAtMs) && createdAtMs >= range.startMs && createdAtMs <= range.endMs) {
+        return true;
+    }
+    return false;
+}
+function parseTaskPointMs(point) {
+    if (!point?.iso) {
+        return null;
+    }
+    const timestamp = Date.parse(point.iso);
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
+function normalizeString(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {