@dinoxx/dinox-cli 2.1.1 → 2.3.0

package/dist/vendor/electron/domain/saved-view-analytics.d.ts

@@ -0,0 +1,45 @@
+import type { PropertyType, SavedViewAnalyticsInput, SavedViewAnalyticsRow, SavedViewChart, SavedViewChartMeasure, SavedViewComputedColumn, SavedViewStat, SavedViewSummaryItem } from "../shared/index.js";
+import type { SqlExecutor } from "../rpc.js";
+import type { SavedViewQueryScope } from "./saved-views.js";
+/**
+ * Saved-view analytics compiler: stats / charts / summary row on top of the view scope.
+ *
+ * Contract shared with dinox-app (`database/sql/savedViewChartSql.ts`):
+ * - Same data range as the table: owner + not deleted + view filter (never the page).
+ * - Charts emit `{ bucket, value }`; stats and summary emit scalar columns `v_<i>`.
+ * - Date buckets use SQLite 'localtime'; week = ISO week starting Monday.
+ * - Multi-value dimensions (tags / multi_select) expand one note into many buckets, so only
+ *   `count` is allowed there and it means "occurrences".
+ * - An item that cannot compile (deleted property, type drift) degrades to `unavailable`
+ *   without failing its siblings.
+ *
+ * Desktop difference: date-only property values ("YYYY-MM-DD") are bucketed as-is instead of
+ * being shifted through 'localtime', which would move them a day back west of UTC.
+ */
+export declare const DEFAULT_SAVED_VIEW_CHART_TIME_LIMIT = 366;
+export declare const DEFAULT_SAVED_VIEW_CHART_CATEGORY_LIMIT = 50;
+export type SavedViewAnalyticsPropertyTypes = ReadonlyMap<string, PropertyType>;
+/** Compile a measure to an aggregate expression; `aliasPrefix` isolates correlated subqueries. */
+export declare function compileSavedViewMeasure(measure: SavedViewChartMeasure, types: SavedViewAnalyticsPropertyTypes, aliasPrefix: string, options?: {
+    dimensionIsMultiValue?: boolean;
+}): string | null;
+export interface CompiledSavedViewSql {
+    sql: string;
+    params: unknown[];
+}
+export declare function compileSavedViewChartSql(chart: SavedViewChart, scope: SavedViewQueryScope, userId: string, types: SavedViewAnalyticsPropertyTypes): CompiledSavedViewSql | null;
+/** Several scalar measures in one pass: `SELECT agg AS v_0, agg AS v_1 ...`. */
+export declare function compileSavedViewScalarSql(measures: ReadonlyArray<SavedViewChartMeasure | null>, scope: SavedViewQueryScope, userId: string, types: SavedViewAnalyticsPropertyTypes, aliasPrefix: string): {
+    sql: string | null;
+    params: unknown[];
+    columns: Array<string | null>;
+};
+/** Summary cells reuse the measure IR: count = rows, sum/avg = number prop or calc column. */
+export declare function summaryItemToMeasure(item: SavedViewSummaryItem, computedColumns: readonly SavedViewComputedColumn[], types: SavedViewAnalyticsPropertyTypes): SavedViewChartMeasure | null;
+export declare function collectSavedViewAnalyticsPropertyKeys(parts: {
+    stats: readonly SavedViewStat[];
+    charts: readonly SavedViewChart[];
+    computedColumns: readonly SavedViewComputedColumn[];
+    summary: readonly SavedViewSummaryItem[];
+}): string[];
+export declare function fetchSavedViewAnalytics(executor: SqlExecutor, input: SavedViewAnalyticsInput, scope: SavedViewQueryScope): Promise<SavedViewAnalyticsRow>;

package/dist/vendor/electron/domain/saved-view-analytics.js

@@ -0,0 +1,365 @@
+import { canGroupSavedViewChartByField, canUseSavedViewChartMeasureField, isPropertyType, isSavedViewDateField, isSavedViewDisplayOnlyField, isSavedViewMultiValueField, MAX_SAVED_VIEW_CHART_LIMIT, } from "../shared/index.js";
+/**
+ * Saved-view analytics compiler: stats / charts / summary row on top of the view scope.
+ *
+ * Contract shared with dinox-app (`database/sql/savedViewChartSql.ts`):
+ * - Same data range as the table: owner + not deleted + view filter (never the page).
+ * - Charts emit `{ bucket, value }`; stats and summary emit scalar columns `v_<i>`.
+ * - Date buckets use SQLite 'localtime'; week = ISO week starting Monday.
+ * - Multi-value dimensions (tags / multi_select) expand one note into many buckets, so only
+ *   `count` is allowed there and it means "occurrences".
+ * - An item that cannot compile (deleted property, type drift) degrades to `unavailable`
+ *   without failing its siblings.
+ *
+ * Desktop difference: date-only property values ("YYYY-MM-DD") are bucketed as-is instead of
+ * being shifted through 'localtime', which would move them a day back west of UTC.
+ */
+export const DEFAULT_SAVED_VIEW_CHART_TIME_LIMIT = 366;
+export const DEFAULT_SAVED_VIEW_CHART_CATEGORY_LIMIT = 50;
+const NOTE_PROPERTIES_JSON = "CASE WHEN json_valid(n.properties) THEN n.properties ELSE '{}' END";
+const DIMENSION_ALIAS = "chart_dim";
+const SCALAR_VALUE_TYPES = "('text', 'integer', 'real', 'true', 'false')";
+const SYS_DATE_COLUMNS = {
+    "sys.created_at": "n.created_at",
+    "sys.updated_at": "n.updated_at",
+    "sys.starred_at": "n.starred_at",
+};
+const SYS_SCALAR_COLUMNS = {
+    "sys.source": "n.source",
+    "sys.type": "n.type",
+};
+const SYS_ARRAY_COLUMNS = {
+    "sys.tags": "n.tags",
+    "sys.zettel_boxes": "n.zettel_boxes",
+};
+function quote(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function propertyKey(field) {
+    return field.startsWith("prop.") ? field.slice("prop.".length) : null;
+}
+function propertyType(field, types) {
+    const key = propertyKey(field);
+    return key ? types.get(key) : undefined;
+}
+function safeJsonArray(column) {
+    return `CASE WHEN json_valid(${column}) AND json_type(${column}) = 'array' THEN ${column} ELSE json('[]') END`;
+}
+/** Invalid or missing numbers stay NULL; a bare CAST would turn bad text into zero. */
+function numberPropertySql(key, alias) {
+    return `(SELECT CAST(${alias}.value AS REAL) FROM json_each(${NOTE_PROPERTIES_JSON}) AS ${alias} WHERE ${alias}.key = ${quote(key)} AND ${alias}.type IN ('integer', 'real'))`;
+}
+function timeBucketSql(base, bucket) {
+    switch (bucket) {
+        case "hour":
+            return `strftime('%Y-%m-%d %H:00', ${base})`;
+        case "day":
+            return `DATE(${base})`;
+        case "week":
+            // Step back 6 days, then forward to the nearest Monday: the ISO week start.
+            return `DATE(${base}, '-6 days', 'weekday 1')`;
+        case "month":
+            return `strftime('%Y-%m', ${base})`;
+    }
+}
+function compileDimension(chart, types) {
+    const dimension = chart.dimensions[0];
+    if (!dimension)
+        return null;
+    const type = propertyType(dimension.field, types);
+    if (!canGroupSavedViewChartByField(dimension.field, type))
+        return null;
+    const isDate = isSavedViewDateField(dimension.field, type);
+    if (isDate !== Boolean(dimension.timeBucket))
+        return null;
+    if (dimension.field.startsWith("sys.")) {
+        const dateColumn = SYS_DATE_COLUMNS[dimension.field];
+        if (dateColumn && dimension.timeBucket) {
+            return {
+                expression: timeBucketSql(`datetime(${dateColumn}, 'localtime')`, dimension.timeBucket),
+                joins: "",
+                conditions: [`${dateColumn} IS NOT NULL AND ${dateColumn} <> ''`],
+            };
+        }
+        const scalarColumn = SYS_SCALAR_COLUMNS[dimension.field];
+        if (scalarColumn) {
+            return {
+                expression: scalarColumn,
+                joins: "",
+                conditions: [`${scalarColumn} IS NOT NULL AND ${scalarColumn} <> ''`],
+            };
+        }
+        const arrayColumn = SYS_ARRAY_COLUMNS[dimension.field];
+        if (arrayColumn) {
+            return {
+                expression: `${DIMENSION_ALIAS}.value`,
+                joins: `, json_each(${safeJsonArray(arrayColumn)}) AS ${DIMENSION_ALIAS}`,
+                conditions: [
+                    `${DIMENSION_ALIAS}.type = 'text'`,
+                    `trim(${DIMENSION_ALIAS}.value) <> ''`,
+                ],
+                label: dimension.field === "sys.zettel_boxes"
+                    ? (bucket) => `(SELECT COALESCE(NULLIF(trim(box.path), ''), NULLIF(trim(box.name), '')) FROM c_zettel_box AS box WHERE box.id = ${bucket} AND (box.is_del IS NULL OR box.is_del = 0) LIMIT 1)`
+                    : undefined,
+            };
+        }
+        return null;
+    }
+    const key = propertyKey(dimension.field);
+    if (!key || !type)
+        return null;
+    const property = `${DIMENSION_ALIAS}_property`;
+    const value = `${DIMENSION_ALIAS}.value`;
+    const joins = ` JOIN json_each(${NOTE_PROPERTIES_JSON}) AS ${property}` +
+        ` JOIN json_each(CASE WHEN ${property}.type = 'array' THEN ${property}.value ELSE json_array(${property}.value) END) AS ${DIMENSION_ALIAS}` +
+        ` ON ${property}.key = ${quote(key)}` +
+        ` AND ${property}.type IN ('text', 'integer', 'real', 'true', 'false', 'array')` +
+        ` AND ${DIMENSION_ALIAS}.type IN ${SCALAR_VALUE_TYPES}` +
+        ` AND ${value} <> ''`;
+    if (type === "date" && dimension.timeBucket) {
+        return {
+            expression: timeBucketSql(`CASE WHEN length(${value}) = 10 THEN ${value} ELSE datetime(${value}, 'localtime') END`, dimension.timeBucket),
+            joins,
+            conditions: [`${DIMENSION_ALIAS}.type = 'text'`],
+        };
+    }
+    const conditions = type === "number"
+        ? [`${DIMENSION_ALIAS}.type IN ('integer', 'real')`]
+        : type === "checkbox"
+            ? [`${DIMENSION_ALIAS}.type IN ('integer', 'real', 'true', 'false')`]
+            : [`${DIMENSION_ALIAS}.type = 'text'`];
+    return { expression: value, joins, conditions };
+}
+/** Compile a measure to an aggregate expression; `aliasPrefix` isolates correlated subqueries. */
+export function compileSavedViewMeasure(measure, types, aliasPrefix, options = {}) {
+    if (measure.aggregation === "count") {
+        return measure.field === null && measure.expr === undefined ? "COUNT(*)" : null;
+    }
+    // Expanded rows != notes, so sum/avg over a multi-value dimension would double count.
+    if (options.dimensionIsMultiValue)
+        return null;
+    const aggregate = measure.aggregation === "sum" ? "SUM" : "AVG";
+    const numberSql = (field, alias) => {
+        const key = propertyKey(field);
+        if (!key || !canUseSavedViewChartMeasureField(field, types.get(key))) {
+            return null;
+        }
+        return numberPropertySql(key, alias);
+    };
+    if (measure.expr) {
+        if (measure.field !== null)
+            return null;
+        const left = numberSql(measure.expr.left, `${aliasPrefix}_l`);
+        const right = numberSql(measure.expr.right, `${aliasPrefix}_r`);
+        if (!left || !right)
+            return null;
+        // Division by zero yields NULL so SUM/AVG skip the row instead of producing Inf.
+        const row = measure.expr.op === "/"
+            ? `(${left} / NULLIF(${right}, 0))`
+            : `(${left} ${measure.expr.op} ${right})`;
+        return `${aggregate}(${row})`;
+    }
+    if (measure.field === null)
+        return null;
+    const single = numberSql(measure.field, aliasPrefix);
+    return single ? `${aggregate}(${single})` : null;
+}
+function resolveOrderClause(chart) {
+    const hasTimeBucket = Boolean(chart.dimensions[0]?.timeBucket);
+    const orderBy = chart.orderBy ?? {
+        by: hasTimeBucket ? "bucket" : "value",
+        direction: hasTimeBucket ? "asc" : "desc",
+    };
+    const direction = orderBy.direction === "asc" ? "ASC" : "DESC";
+    return orderBy.by === "bucket"
+        ? `bucket ${direction}`
+        : `value ${direction}, bucket ASC`;
+}
+function resolveLimit(chart) {
+    const fallback = chart.dimensions[0]?.timeBucket
+        ? DEFAULT_SAVED_VIEW_CHART_TIME_LIMIT
+        : DEFAULT_SAVED_VIEW_CHART_CATEGORY_LIMIT;
+    const requested = chart.limit;
+    if (typeof requested !== "number" || !Number.isInteger(requested) || requested < 1) {
+        return fallback;
+    }
+    return Math.min(requested, MAX_SAVED_VIEW_CHART_LIMIT);
+}
+function scopeWhere(scope, userId) {
+    return {
+        sql: `n.user_no = ? AND (n.is_del IS NULL OR n.is_del = 0) AND (${scope.where.sql})`,
+        params: [userId, ...scope.where.params],
+    };
+}
+export function compileSavedViewChartSql(chart, scope, userId, types) {
+    const dimension = compileDimension(chart, types);
+    const measure = chart.measures[0];
+    if (!dimension || !measure)
+        return null;
+    const dimensionField = chart.dimensions[0].field;
+    const aggregate = compileSavedViewMeasure(measure, types, "chart_measure", {
+        dimensionIsMultiValue: isSavedViewMultiValueField(dimensionField, propertyType(dimensionField, types)),
+    });
+    if (!aggregate)
+        return null;
+    const where = scopeWhere(scope, userId);
+    const inner = `SELECT ${dimension.expression} AS bucket, ${aggregate} AS value ` +
+        `FROM c_note AS n${dimension.joins} ` +
+        `WHERE ${[where.sql, ...dimension.conditions].join(" AND ")} ` +
+        "GROUP BY bucket HAVING bucket IS NOT NULL " +
+        `ORDER BY ${resolveOrderClause(chart)} LIMIT ${resolveLimit(chart)}`;
+    const sql = dimension.label
+        ? `SELECT grouped.bucket, grouped.value, ${dimension.label("grouped.bucket")} AS label FROM (${inner}) AS grouped`
+        : inner;
+    return { sql, params: where.params };
+}
+/** Several scalar measures in one pass: `SELECT agg AS v_0, agg AS v_1 ...`. */
+export function compileSavedViewScalarSql(measures, scope, userId, types, aliasPrefix) {
+    const columns = measures.map((measure, index) => measure ? compileSavedViewMeasure(measure, types, `${aliasPrefix}_${index}`) : null);
+    const selected = columns.flatMap((expression, index) => expression ? [`${expression} AS v_${index}`] : []);
+    if (selected.length === 0)
+        return { sql: null, params: [], columns };
+    const where = scopeWhere(scope, userId);
+    return {
+        sql: `SELECT ${selected.join(", ")} FROM c_note AS n WHERE ${where.sql}`,
+        params: where.params,
+        columns,
+    };
+}
+/** Summary cells reuse the measure IR: count = rows, sum/avg = number prop or calc column. */
+export function summaryItemToMeasure(item, computedColumns, types) {
+    if (item.column.startsWith("sys.") &&
+        isSavedViewDisplayOnlyField(item.column)) {
+        return null;
+    }
+    if (item.aggregation === "count")
+        return { field: null, aggregation: "count" };
+    if (item.column.startsWith("calc.")) {
+        const id = item.column.slice("calc.".length);
+        const computed = computedColumns.find((column) => column.id === id);
+        return computed
+            ? { field: null, aggregation: item.aggregation, expr: computed.expr }
+            : null;
+    }
+    const field = item.column;
+    return canUseSavedViewChartMeasureField(field, propertyType(field, types))
+        ? { field, aggregation: item.aggregation }
+        : null;
+}
+export function collectSavedViewAnalyticsPropertyKeys(parts) {
+    const keys = new Set();
+    const addField = (field) => {
+        const key = field ? propertyKey(field) : null;
+        if (key)
+            keys.add(key);
+    };
+    const addMeasure = (measure) => {
+        addField(measure?.field);
+        addField(measure?.expr?.left);
+        addField(measure?.expr?.right);
+    };
+    for (const stat of parts.stats)
+        addMeasure(stat.measure);
+    for (const chart of parts.charts) {
+        addField(chart.dimensions[0]?.field);
+        addMeasure(chart.measures[0]);
+    }
+    for (const column of parts.computedColumns) {
+        addField(column.expr.left);
+        addField(column.expr.right);
+    }
+    for (const item of parts.summary) {
+        if (item.column.startsWith("prop."))
+            addField(item.column);
+    }
+    return [...keys];
+}
+async function loadPropertyTypes(executor, userId, keys) {
+    const types = new Map();
+    if (keys.length === 0)
+        return types;
+    const rows = await executor.getAll(`
+      SELECT ranked.key, ranked.type
+      FROM (
+        SELECT
+          key,
+          type,
+          ROW_NUMBER() OVER (
+            PARTITION BY key
+            ORDER BY
+              COALESCE(NULLIF(updated_at, ''), NULLIF(created_at, ''), id) DESC,
+              id DESC
+          ) AS key_rank
+        FROM c_property_def
+        WHERE user_id = ?
+          AND key IN (${keys.map(() => "?").join(", ")})
+          AND (is_del IS NULL OR is_del = 0)
+      ) AS ranked
+      WHERE ranked.key_rank = 1
+    `, [userId, ...keys]);
+    for (const row of rows) {
+        if (row.key && isPropertyType(row.type))
+            types.set(row.key, row.type);
+    }
+    return types;
+}
+function toFiniteNumber(raw) {
+    if (typeof raw === "number")
+        return Number.isFinite(raw) ? raw : null;
+    if (typeof raw === "string" && raw.trim() !== "") {
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+export async function fetchSavedViewAnalytics(executor, input, scope) {
+    const stats = input.draft?.stats ?? scope.config.stats ?? [];
+    const charts = input.draft?.charts ?? scope.config.charts ?? [];
+    const computedColumns = input.draft?.computedColumns ?? scope.config.computedColumns ?? [];
+    const summary = input.draft?.summary ?? scope.config.summary ?? [];
+    const types = await loadPropertyTypes(executor, input.userId, collectSavedViewAnalyticsPropertyKeys({ stats, charts, computedColumns, summary }));
+    const readScalars = async (measures, aliasPrefix) => {
+        const compiled = compileSavedViewScalarSql(measures, scope, input.userId, types, aliasPrefix);
+        const row = compiled.sql
+            ? await executor.getOptional(compiled.sql, compiled.params)
+            : null;
+        return compiled.columns.map((expression, index) => ({
+            unavailable: expression === null,
+            value: expression && row ? toFiniteNumber(row[`v_${index}`]) : null,
+        }));
+    };
+    const statValues = await readScalars(stats.map((stat) => stat.measure), "stat");
+    const summaryValues = await readScalars(summary.map((item) => summaryItemToMeasure(item, computedColumns, types)), "summary");
+    const chartResults = [];
+    for (const chart of charts) {
+        const compiled = compileSavedViewChartSql(chart, scope, input.userId, types);
+        if (!compiled) {
+            chartResults.push({ id: chart.id, rows: [], unavailable: true });
+            continue;
+        }
+        const rows = await executor.getAll(compiled.sql, compiled.params);
+        chartResults.push({
+            id: chart.id,
+            unavailable: false,
+            rows: rows.map((row) => ({
+                bucket: row.bucket ?? null,
+                value: toFiniteNumber(row.value),
+                ...(row.label !== undefined ? { label: row.label ?? null } : {}),
+            })),
+        });
+    }
+    return {
+        stats: stats.map((stat, index) => ({
+            id: stat.id,
+            value: statValues[index]?.value ?? null,
+            unavailable: statValues[index]?.unavailable ?? true,
+        })),
+        charts: chartResults,
+        summary: summary.map((item, index) => ({
+            column: item.column,
+            aggregation: item.aggregation,
+            value: summaryValues[index]?.value ?? null,
+            unavailable: summaryValues[index]?.unavailable ?? true,
+        })),
+    };
+}

package/dist/vendor/electron/domain/saved-view-relative-date.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Inputs: a dynamic saved-view date operator, an optional rolling-day count, current time, and IANA timezone.
+ * Outputs: deterministic half-open calendar boundaries for main-owned saved-view SQL compilation.
+ */
+import { type SavedViewFilterOperator } from "../shared/index.js";
+type DynamicDateOperator = Extract<SavedViewFilterOperator, "withinLastDays" | "isToday" | "isThisWeek" | "isThisMonth">;
+export type SavedViewRelativeDateRange = {
+    timeZone: string;
+    startDate: string;
+    endDateExclusive: string;
+    startInstant: string;
+    endInstantExclusive: string;
+};
+export declare function resolveSavedViewTimeZone(value?: string): string;
+export declare function resolveSavedViewRelativeDateRange(options: {
+    operator: DynamicDateOperator;
+    value?: unknown;
+    now?: Date;
+    timeZone?: string;
+}): SavedViewRelativeDateRange;
+export {};

package/dist/vendor/electron/domain/saved-view-relative-date.js

@@ -0,0 +1,153 @@
+// Generated by scripts/sync-electron-domain.ts from dinox-electron/packages/main/src/modules/powersync/typed-rpc/domain/saved-view-relative-date.ts. Do not edit manually.
+/**
+ * Inputs: a dynamic saved-view date operator, an optional rolling-day count, current time, and IANA timezone.
+ * Outputs: deterministic half-open calendar boundaries for main-owned saved-view SQL compilation.
+ */
+import { MAX_SAVED_VIEW_RELATIVE_DAYS, } from "../shared/index.js";
+const UTC_TIME_ZONE = "UTC";
+const dateTimeFormatters = new Map();
+export function resolveSavedViewTimeZone(value) {
+    const requested = value?.trim();
+    if (requested) {
+        if (!isSupportedTimeZone(requested)) {
+            throw new Error("SAVED_VIEW_INVALID_TIME_ZONE");
+        }
+        return requested;
+    }
+    const local = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return local && isSupportedTimeZone(local) ? local : UTC_TIME_ZONE;
+}
+export function resolveSavedViewRelativeDateRange(options) {
+    const now = options.now ?? new Date();
+    if (Number.isNaN(now.getTime())) {
+        throw new Error("SAVED_VIEW_INVALID_CURRENT_TIME");
+    }
+    const timeZone = resolveSavedViewTimeZone(options.timeZone);
+    const today = getCalendarDate(now, timeZone);
+    let start;
+    let endExclusive;
+    switch (options.operator) {
+        case "withinLastDays": {
+            const days = options.value;
+            if (typeof days !== "number" ||
+                !Number.isInteger(days) ||
+                days < 1 ||
+                days > MAX_SAVED_VIEW_RELATIVE_DAYS) {
+                throw new Error("SAVED_VIEW_INVALID_RELATIVE_DAYS");
+            }
+            start = addCalendarDays(today, -(days - 1));
+            endExclusive = addCalendarDays(today, 1);
+            break;
+        }
+        case "isToday":
+            start = today;
+            endExclusive = addCalendarDays(today, 1);
+            break;
+        case "isThisWeek": {
+            // Saved views use ISO calendar weeks (Monday through Sunday).
+            const dayOfWeek = getIsoDayOfWeek(today);
+            start = addCalendarDays(today, -(dayOfWeek - 1));
+            endExclusive = addCalendarDays(start, 7);
+            break;
+        }
+        case "isThisMonth":
+            start = { year: today.year, month: today.month, day: 1 };
+            endExclusive = addCalendarMonths(start, 1);
+            break;
+    }
+    return {
+        timeZone,
+        startDate: formatCalendarDate(start),
+        endDateExclusive: formatCalendarDate(endExclusive),
+        startInstant: zonedMidnightToInstant(start, timeZone).toISOString(),
+        endInstantExclusive: zonedMidnightToInstant(endExclusive, timeZone).toISOString(),
+    };
+}
+function isSupportedTimeZone(value) {
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: value }).format(new Date());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getDateTimeFormatter(timeZone) {
+    const cached = dateTimeFormatters.get(timeZone);
+    if (cached)
+        return cached;
+    const formatter = new Intl.DateTimeFormat("en-US-u-ca-iso8601-nu-latn", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    });
+    dateTimeFormatters.set(timeZone, formatter);
+    return formatter;
+}
+function getZonedDateTimeParts(value, timeZone) {
+    const parts = getDateTimeFormatter(timeZone).formatToParts(value);
+    const read = (type) => {
+        const parsed = Number(parts.find((part) => part.type === type)?.value);
+        if (!Number.isFinite(parsed)) {
+            throw new Error("SAVED_VIEW_TIME_ZONE_CONVERSION_FAILED");
+        }
+        return parsed;
+    };
+    return {
+        year: read("year"),
+        month: read("month"),
+        day: read("day"),
+        hour: read("hour"),
+        minute: read("minute"),
+        second: read("second"),
+    };
+}
+function getCalendarDate(value, timeZone) {
+    const parts = getZonedDateTimeParts(value, timeZone);
+    return { year: parts.year, month: parts.month, day: parts.day };
+}
+function addCalendarDays(value, days) {
+    const date = new Date(Date.UTC(value.year, value.month - 1, value.day + days));
+    return {
+        year: date.getUTCFullYear(),
+        month: date.getUTCMonth() + 1,
+        day: date.getUTCDate(),
+    };
+}
+function addCalendarMonths(value, months) {
+    const date = new Date(Date.UTC(value.year, value.month - 1 + months, 1));
+    return {
+        year: date.getUTCFullYear(),
+        month: date.getUTCMonth() + 1,
+        day: date.getUTCDate(),
+    };
+}
+function getIsoDayOfWeek(value) {
+    const day = new Date(Date.UTC(value.year, value.month - 1, value.day)).getUTCDay();
+    return day === 0 ? 7 : day;
+}
+function formatCalendarDate(value) {
+    return [
+        String(value.year).padStart(4, "0"),
+        String(value.month).padStart(2, "0"),
+        String(value.day).padStart(2, "0"),
+    ].join("-");
+}
+function zonedMidnightToInstant(value, timeZone) {
+    const targetAsUtc = Date.UTC(value.year, value.month - 1, value.day);
+    let instant = targetAsUtc;
+    for (let iteration = 0; iteration < 4; iteration += 1) {
+        const actual = getZonedDateTimeParts(new Date(instant), timeZone);
+        const actualAsUtc = Date.UTC(actual.year, actual.month - 1, actual.day, actual.hour, actual.minute, actual.second);
+        const correction = targetAsUtc - actualAsUtc;
+        instant += correction;
+        if (correction === 0)
+            break;
+    }
+    return new Date(instant);
+}

package/dist/vendor/electron/domain/saved-views.d.ts

@@ -0,0 +1,61 @@
+import type { PropertyOption, PropertyType, SavedViewConfig, SavedViewCountInput, SavedViewFieldRef, SavedViewFilter, SavedViewNoteDetailInput, SavedViewNoteDetailSection, SavedViewPageInput, SavedViewPageRow } from "../shared/index.js";
+import type { AbstractPowerSyncDatabase as PowerSyncDatabase } from "@powersync/common";
+import { type CommandDefinition, type ReadModelDefinition, type SqlExecutor } from "../rpc.js";
+export type SavedViewResolvedDefinition = {
+    id: string;
+    name: string | null;
+    emoji: string | null;
+    filter_json: string | null;
+    view_type: string | null;
+    config_json: string | null;
+    updated_at: string | null;
+};
+export type SavedViewSqlFragment = {
+    sql: string;
+    params: unknown[];
+};
+export interface SavedViewQueryScope {
+    definition: SavedViewResolvedDefinition;
+    filter: SavedViewFilter;
+    config: SavedViewConfig;
+    semantics: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>;
+    where: SavedViewSqlFragment;
+    order: SavedViewSqlFragment;
+}
+type SavedViewSemanticType = "text" | "select" | "list" | "number" | "date" | "boolean";
+export type SavedViewFieldSemantic = {
+    type: SavedViewSemanticType;
+    propertyType?: PropertyType;
+    dateMode?: "date" | "datetime";
+    options?: readonly PropertyOption[];
+    displayOnly?: boolean;
+};
+export declare function createSavedViewReadModels(): ReadModelDefinition[];
+export declare function createSavedViewCommands(): CommandDefinition[];
+export declare function resolveSavedViewQueryScope(executor: SqlExecutor, input: Pick<SavedViewPageInput, "viewId" | "userId" | "timeZone">): Promise<SavedViewQueryScope>;
+export declare function fetchSavedViewNoteDetail(executor: SqlExecutor, input: SavedViewNoteDetailInput): Promise<SavedViewNoteDetailSection[]>;
+export declare function fetchSavedViewScopedPage(executor: SqlExecutor, input: SavedViewPageInput, scope?: SavedViewQueryScope): Promise<SavedViewPageRow[]>;
+export declare function countSavedViewScopedRows(executor: SqlExecutor, input: SavedViewCountInput, scope?: SavedViewQueryScope): Promise<number>;
+export declare function filterSavedViewNoteIds(executor: SqlExecutor, input: Pick<SavedViewPageInput, "viewId" | "userId" | "timeZone"> & {
+    noteIds: readonly string[];
+}, scope?: SavedViewQueryScope): Promise<string[]>;
+export type SavedViewFilterCompileOptions = {
+    now?: Date;
+    timeZone?: string;
+};
+export declare function compileFilter(filter: SavedViewFilter, semantics?: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>, options?: SavedViewFilterCompileOptions): SavedViewSqlFragment;
+export declare function compileOrder(config: SavedViewConfig, semantics?: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>): SavedViewSqlFragment;
+/**
+ * Read-modify-write of one view's config inside a single write transaction, for writers
+ * that only touch the analytics layer (Agent tools). `apply` receives the stored config and
+ * returns the next one; filter, columns and sort stay as stored.
+ */
+export declare function updateSavedViewConfig(db: PowerSyncDatabase, input: {
+    viewId: string;
+    userId: string;
+    updatedAt: string;
+}, apply: (config: SavedViewConfig) => SavedViewConfig): Promise<{
+    previous: SavedViewConfig;
+    next: SavedViewConfig;
+}>;
+export {};