@affino/datagrid-vue-app 0.1.1

package/dist/config/dataGridFormulaOptions.d.ts

@@ -0,0 +1,25 @@
+import type { CreateClientRowModelOptions, DataGridColumnInput, DataGridComputedFieldDefinition, DataGridFormulaFieldDefinition, DataGridFormulaFunctionRegistry } from "@affino/datagrid-vue";
+/**
+ * High-level authored column contract for `@affino/datagrid-vue-app`.
+ */
+export interface DataGridAppColumnInput extends DataGridColumnInput {
+    formula?: string | null;
+}
+export interface DataGridDeclarativeFormulaOptions<TRow = unknown> {
+    formulas?: readonly DataGridFormulaFieldDefinition[] | null;
+    computedFields?: readonly DataGridComputedFieldDefinition<TRow>[] | null;
+    formulaFunctions?: DataGridFormulaFunctionRegistry | null;
+}
+export type DataGridAppClientRowModelOptions<TRow = unknown> = Omit<CreateClientRowModelOptions<TRow>, "rows" | "computeMode" | "workerPatchDispatchThreshold" | "formulaColumnCacheMaxColumns">;
+export interface DataGridAppEnterpriseFormulaRuntimeOptions {
+    computeMode?: "sync" | "worker";
+    workerPatchDispatchThreshold?: number | null;
+    formulaColumnCacheMaxColumns?: number | null;
+}
+export interface ResolveDataGridFormulaRowModelOptionsInput<TRow = unknown> extends DataGridDeclarativeFormulaOptions<TRow> {
+    columns?: readonly DataGridAppColumnInput[] | null | undefined;
+    clientRowModelOptions?: DataGridAppClientRowModelOptions<TRow> | undefined;
+    enterpriseClientRowModelOptions?: DataGridAppEnterpriseFormulaRuntimeOptions | undefined;
+}
+export declare function resolveDataGridColumns(columns: readonly DataGridAppColumnInput[] | null | undefined): readonly DataGridColumnInput[];
+export declare function resolveDataGridFormulaRowModelOptions<TRow = unknown>(input: ResolveDataGridFormulaRowModelOptionsInput<TRow>): Omit<CreateClientRowModelOptions<TRow>, "rows"> | undefined;

package/dist/config/dataGridFormulaOptions.js

@@ -0,0 +1,137 @@
+const CLIENT_ROW_MODEL_OPTIONS_CACHE = new WeakMap();
+const MERGED_ROW_MODEL_OPTIONS_CACHE = new WeakMap();
+function cloneClientRowModelOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    const cached = CLIENT_ROW_MODEL_OPTIONS_CACHE.get(options);
+    if (cached) {
+        return cached;
+    }
+    const normalizedExpandedByDefault = options.initialTreeData?.expandedByDefault ?? false;
+    if (options.initialTreeData?.expandedByDefault === normalizedExpandedByDefault) {
+        CLIENT_ROW_MODEL_OPTIONS_CACHE.set(options, options);
+        return options;
+    }
+    const cloned = {
+        ...options,
+    };
+    if (options.initialTreeData) {
+        cloned.initialTreeData = {
+            ...options.initialTreeData,
+            expandedByDefault: normalizedExpandedByDefault,
+        };
+    }
+    CLIENT_ROW_MODEL_OPTIONS_CACHE.set(options, cloned);
+    return cloned;
+}
+function cloneFormulas(formulas) {
+    if (!formulas || formulas.length === 0) {
+        return [];
+    }
+    return formulas.map(entry => ({ ...entry }));
+}
+function cloneComputedFields(computedFields) {
+    if (!computedFields || computedFields.length === 0) {
+        return [];
+    }
+    return computedFields.map(entry => ({ ...entry }));
+}
+function cloneColumns(columns) {
+    if (!columns || columns.length === 0) {
+        return [];
+    }
+    return columns.map(({ formula: _formula, ...column }) => ({ ...column }));
+}
+function extractEmbeddedFormulas(columns) {
+    if (!columns || columns.length === 0) {
+        return [];
+    }
+    return columns.flatMap(column => {
+        const formula = typeof column.formula === "string" ? column.formula.trim() : "";
+        if (!formula) {
+            return [];
+        }
+        return [{
+                name: column.key,
+                formula,
+            }];
+    });
+}
+function mergeFormulaDefinitions(embeddedFormulas, formulas) {
+    const merged = new Map();
+    for (const entry of embeddedFormulas) {
+        merged.set(entry.name, { ...entry });
+    }
+    for (const entry of cloneFormulas(formulas)) {
+        merged.set(entry.name, entry);
+    }
+    return Array.from(merged.values());
+}
+export function resolveDataGridColumns(columns) {
+    return cloneColumns(columns);
+}
+export function resolveDataGridFormulaRowModelOptions(input) {
+    const baseOptions = cloneClientRowModelOptions(input.clientRowModelOptions);
+    const enterpriseOptions = input.enterpriseClientRowModelOptions;
+    const embeddedFormulas = extractEmbeddedFormulas(input.columns);
+    const hasFormulaProp = input.formulas !== undefined;
+    const hasComputedFieldsProp = input.computedFields !== undefined;
+    const hasFormulaFunctionsProp = input.formulaFunctions !== undefined;
+    const hasEmbeddedFormulas = embeddedFormulas.length > 0;
+    const initialFormulaFields = hasFormulaProp || hasEmbeddedFormulas
+        ? mergeFormulaDefinitions(embeddedFormulas, input.formulas)
+        : undefined;
+    const initialComputedFields = hasComputedFieldsProp ? cloneComputedFields(input.computedFields) : undefined;
+    const initialFormulaFunctionRegistry = hasFormulaFunctionsProp ? (input.formulaFunctions ?? {}) : undefined;
+    const hasFormulaOverrides = Boolean(hasEmbeddedFormulas
+        || hasFormulaProp
+        || hasComputedFieldsProp
+        || hasFormulaFunctionsProp);
+    if (!baseOptions && !hasFormulaOverrides) {
+        if (!enterpriseOptions) {
+            return undefined;
+        }
+        return {
+            ...enterpriseOptions,
+        };
+    }
+    if (!hasFormulaOverrides) {
+        if (baseOptions && !enterpriseOptions) {
+            return baseOptions;
+        }
+        if (!baseOptions && enterpriseOptions) {
+            return enterpriseOptions;
+        }
+        if (baseOptions && enterpriseOptions) {
+            let byEnterprise = MERGED_ROW_MODEL_OPTIONS_CACHE.get(baseOptions);
+            if (!byEnterprise) {
+                byEnterprise = new WeakMap();
+                MERGED_ROW_MODEL_OPTIONS_CACHE.set(baseOptions, byEnterprise);
+            }
+            const cached = byEnterprise.get(enterpriseOptions);
+            if (cached) {
+                return cached;
+            }
+            const merged = {
+                ...baseOptions,
+                ...enterpriseOptions,
+            };
+            byEnterprise.set(enterpriseOptions, merged);
+            return merged;
+        }
+    }
+    return {
+        ...(baseOptions ?? {}),
+        ...(hasComputedFieldsProp ? { initialComputedFields } : {}),
+        ...(hasFormulaProp || hasEmbeddedFormulas ? { initialFormulaFields } : {}),
+        ...(hasFormulaFunctionsProp ? { initialFormulaFunctionRegistry } : {}),
+        ...(enterpriseOptions?.computeMode ? { computeMode: enterpriseOptions.computeMode } : {}),
+        ...(enterpriseOptions?.workerPatchDispatchThreshold !== undefined
+            ? { workerPatchDispatchThreshold: enterpriseOptions.workerPatchDispatchThreshold }
+            : {}),
+        ...(enterpriseOptions?.formulaColumnCacheMaxColumns !== undefined
+            ? { formulaColumnCacheMaxColumns: enterpriseOptions.formulaColumnCacheMaxColumns }
+            : {}),
+    };
+}

package/dist/config/dataGridPublicProps.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridGroupBySpec, DataGridPaginationInput } from "@affino/datagrid-vue";
+export type DataGridGroupByProp = string | readonly string[] | DataGridGroupBySpec | null;
+export type DataGridPaginationProp = boolean | DataGridPaginationInput | null;
+export declare function resolveDataGridGroupBy(input: DataGridGroupByProp | undefined): DataGridGroupBySpec | null | undefined;
+export declare function resolveDataGridRenderMode(renderMode: "virtualization" | "pagination" | undefined, pagination: DataGridPaginationProp | undefined): "virtualization" | "pagination";
+export declare function resolveDataGridPagination(pagination: DataGridPaginationProp | undefined, renderMode: "virtualization" | "pagination", pageSize: number | undefined, currentPage: number | undefined): DataGridPaginationInput | null;

package/dist/config/dataGridPublicProps.js

@@ -0,0 +1,58 @@
+function normalizePageNumber(value, fallback) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.trunc(value));
+}
+function normalizePageSize(value, fallback) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(1, Math.trunc(value));
+}
+export function resolveDataGridGroupBy(input) {
+    if (input === undefined) {
+        return undefined;
+    }
+    if (input == null) {
+        return null;
+    }
+    if (typeof input === "string") {
+        const field = input.trim();
+        return field ? { fields: [field], expandedByDefault: true } : null;
+    }
+    if (Array.isArray(input)) {
+        const fields = input
+            .map(field => field.trim())
+            .filter(field => field.length > 0);
+        return fields.length > 0 ? { fields: [...fields], expandedByDefault: true } : null;
+    }
+    return input;
+}
+export function resolveDataGridRenderMode(renderMode, pagination) {
+    if (pagination === true) {
+        return "pagination";
+    }
+    if (pagination && typeof pagination === "object") {
+        return "pagination";
+    }
+    return renderMode ?? "virtualization";
+}
+export function resolveDataGridPagination(pagination, renderMode, pageSize, currentPage) {
+    if (renderMode !== "pagination") {
+        return null;
+    }
+    const fallbackPageSize = 100;
+    const resolvedPageSize = normalizePageSize(pageSize, fallbackPageSize);
+    const resolvedCurrentPage = normalizePageNumber(currentPage, 0);
+    if (pagination === true || pagination === false || pagination == null) {
+        return {
+            pageSize: resolvedPageSize,
+            currentPage: resolvedCurrentPage,
+        };
+    }
+    return {
+        pageSize: normalizePageSize(pageSize ?? pagination.pageSize, fallbackPageSize),
+        currentPage: normalizePageNumber(currentPage ?? pagination.currentPage, 0),
+    };
+}

package/dist/config/dataGridSavedView.d.ts

@@ -0,0 +1,17 @@
+import type { DataGridMigrateStateOptions, DataGridUnifiedState } from "@affino/datagrid-vue";
+import type { DataGridAppViewMode } from "../gantt/dataGridGantt";
+export interface DataGridSavedViewSnapshot<TRow extends Record<string, unknown> = Record<string, unknown>> {
+    state: DataGridUnifiedState<TRow>;
+    viewMode?: DataGridAppViewMode;
+}
+export interface DataGridSavedViewStorageLike {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}
+export declare function migrateDataGridSavedView<TRow extends Record<string, unknown> = Record<string, unknown>>(value: unknown, migrateState: (state: unknown, options?: DataGridMigrateStateOptions) => DataGridUnifiedState<TRow> | null, options?: DataGridMigrateStateOptions): DataGridSavedViewSnapshot<TRow> | null;
+export declare function serializeDataGridSavedView<TRow extends Record<string, unknown> = Record<string, unknown>>(savedView: DataGridSavedViewSnapshot<TRow>): string;
+export declare function parseDataGridSavedView<TRow extends Record<string, unknown> = Record<string, unknown>>(value: string, migrateState: (state: unknown, options?: DataGridMigrateStateOptions) => DataGridUnifiedState<TRow> | null, options?: DataGridMigrateStateOptions): DataGridSavedViewSnapshot<TRow> | null;
+export declare function writeDataGridSavedViewToStorage<TRow extends Record<string, unknown> = Record<string, unknown>>(storage: DataGridSavedViewStorageLike | null | undefined, key: string, savedView: DataGridSavedViewSnapshot<TRow>): boolean;
+export declare function readDataGridSavedViewFromStorage<TRow extends Record<string, unknown> = Record<string, unknown>>(storage: DataGridSavedViewStorageLike | null | undefined, key: string, migrateState: (state: unknown, options?: DataGridMigrateStateOptions) => DataGridUnifiedState<TRow> | null, options?: DataGridMigrateStateOptions): DataGridSavedViewSnapshot<TRow> | null;
+export declare function clearDataGridSavedViewInStorage(storage: DataGridSavedViewStorageLike | null | undefined, key: string): boolean;

package/dist/config/dataGridSavedView.js

@@ -0,0 +1,73 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function migrateDataGridSavedView(value, migrateState, options) {
+    const record = isRecord(value) ? value : null;
+    const migratedState = migrateState(record && "state" in record ? record.state : value, options);
+    if (!migratedState) {
+        return null;
+    }
+    const rawViewMode = record?.viewMode;
+    const viewMode = rawViewMode === "gantt"
+        ? "gantt"
+        : rawViewMode === "table"
+            ? "table"
+            : undefined;
+    return {
+        state: migratedState,
+        ...(viewMode ? { viewMode } : {}),
+    };
+}
+export function serializeDataGridSavedView(savedView) {
+    return JSON.stringify(savedView);
+}
+export function parseDataGridSavedView(value, migrateState, options) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return null;
+    }
+    try {
+        return migrateDataGridSavedView(JSON.parse(value), migrateState, options);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeDataGridSavedViewToStorage(storage, key, savedView) {
+    if (!storage || typeof key !== "string" || key.trim().length === 0) {
+        return false;
+    }
+    try {
+        storage.setItem(key, serializeDataGridSavedView(savedView));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readDataGridSavedViewFromStorage(storage, key, migrateState, options) {
+    if (!storage || typeof key !== "string" || key.trim().length === 0) {
+        return null;
+    }
+    try {
+        const rawValue = storage.getItem(key);
+        if (!rawValue) {
+            return null;
+        }
+        return parseDataGridSavedView(rawValue, migrateState, options);
+    }
+    catch {
+        return null;
+    }
+}
+export function clearDataGridSavedViewInStorage(storage, key) {
+    if (!storage || typeof key !== "string" || key.trim().length === 0) {
+        return false;
+    }
+    try {
+        storage.removeItem(key);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config/dataGridVirtualization.d.ts

@@ -0,0 +1,14 @@
+export interface DataGridVirtualizationOptions {
+    rows: boolean;
+    columns: boolean;
+    rowOverscan: number;
+    columnOverscan: number;
+}
+export type DataGridVirtualizationProp = boolean | {
+    overscan?: number;
+    rows?: boolean;
+    columns?: boolean;
+    rowOverscan?: number;
+    columnOverscan?: number;
+};
+export declare function resolveDataGridVirtualization(input: DataGridVirtualizationProp | undefined, renderMode: "virtualization" | "pagination"): DataGridVirtualizationOptions;

package/dist/config/dataGridVirtualization.js

@@ -0,0 +1,32 @@
+function normalizeOverscan(value, fallback) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.trunc(value));
+}
+export function resolveDataGridVirtualization(input, renderMode) {
+    const defaults = {
+        rows: true,
+        columns: false,
+        rowOverscan: 8,
+        columnOverscan: 2,
+    };
+    if (input === true) {
+        defaults.columns = true;
+    }
+    else if (input === false) {
+        defaults.rows = false;
+        defaults.columns = false;
+    }
+    else if (input && typeof input === "object") {
+        defaults.rows = input.rows ?? defaults.rows;
+        defaults.columns = input.columns ?? defaults.columns;
+        const sharedOverscan = normalizeOverscan(input.overscan, defaults.rowOverscan);
+        defaults.rowOverscan = normalizeOverscan(input.rowOverscan, sharedOverscan);
+        defaults.columnOverscan = normalizeOverscan(input.columnOverscan, normalizeOverscan(input.overscan, defaults.columnOverscan));
+    }
+    if (renderMode === "pagination") {
+        defaults.rows = false;
+    }
+    return defaults;
+}

package/dist/dataGridAdvancedFilter.d.ts

@@ -0,0 +1 @@
+export * from "./config/dataGridAdvancedFilter";

package/dist/dataGridAdvancedFilter.js

@@ -0,0 +1 @@
+export * from "./config/dataGridAdvancedFilter";

package/dist/dataGridAggregations.d.ts

@@ -0,0 +1 @@
+export * from "./config/dataGridAggregations";

package/dist/dataGridAggregations.js

@@ -0,0 +1 @@
+export * from "./config/dataGridAggregations";

package/dist/dataGridAppContext.d.ts

@@ -0,0 +1,2 @@
+import type { InjectionKey, Ref } from "vue";
+export declare const dataGridAppRootElementKey: InjectionKey<Ref<HTMLElement | null>>;

package/dist/dataGridAppContext.js

@@ -0,0 +1 @@
+export const dataGridAppRootElementKey = Symbol("affino-datagrid-app-root-element");

package/dist/dataGridCellComboboxState.d.ts

@@ -0,0 +1,10 @@
+export interface DataGridCellComboboxState {
+    open: boolean;
+    filter: string;
+    activeIndex: number;
+}
+export declare function createDataGridCellComboboxState(initial?: Partial<DataGridCellComboboxState>): DataGridCellComboboxState;
+export declare function setDataGridCellComboboxOpen(state: DataGridCellComboboxState, open: boolean): DataGridCellComboboxState;
+export declare function setDataGridCellComboboxFilter(state: DataGridCellComboboxState, filter: string): DataGridCellComboboxState;
+export declare function activateDataGridCellComboboxIndex(state: DataGridCellComboboxState, index: number, optionCount: number): DataGridCellComboboxState;
+export declare function moveDataGridCellComboboxFocus(state: DataGridCellComboboxState, delta: number, optionCount: number, loop?: boolean): DataGridCellComboboxState;

package/dist/dataGridCellComboboxState.js

@@ -0,0 +1,67 @@
+export function createDataGridCellComboboxState(initial = {}) {
+    return {
+        open: initial.open ?? false,
+        filter: initial.filter ?? "",
+        activeIndex: initial.activeIndex ?? -1,
+    };
+}
+export function setDataGridCellComboboxOpen(state, open) {
+    if (state.open === open) {
+        return state;
+    }
+    return {
+        ...state,
+        open,
+    };
+}
+export function setDataGridCellComboboxFilter(state, filter) {
+    if (state.filter === filter) {
+        return state;
+    }
+    return {
+        ...state,
+        filter,
+    };
+}
+export function activateDataGridCellComboboxIndex(state, index, optionCount) {
+    const nextIndex = clampIndex(index, optionCount);
+    if (nextIndex === state.activeIndex) {
+        return state;
+    }
+    return {
+        ...state,
+        activeIndex: nextIndex,
+    };
+}
+export function moveDataGridCellComboboxFocus(state, delta, optionCount, loop = true) {
+    if (optionCount <= 0 || delta === 0) {
+        return state;
+    }
+    if (state.activeIndex < 0) {
+        return activateDataGridCellComboboxIndex(state, delta > 0 ? 0 : optionCount - 1, optionCount);
+    }
+    const rawTarget = state.activeIndex + Math.trunc(delta);
+    if (loop) {
+        return activateDataGridCellComboboxIndex(state, modulo(rawTarget, optionCount), optionCount);
+    }
+    return activateDataGridCellComboboxIndex(state, rawTarget, optionCount);
+}
+function clampIndex(index, optionCount) {
+    if (optionCount <= 0) {
+        return -1;
+    }
+    if (!Number.isFinite(index)) {
+        return 0;
+    }
+    const normalized = Math.trunc(index);
+    if (normalized < 0) {
+        return 0;
+    }
+    if (normalized >= optionCount) {
+        return optionCount - 1;
+    }
+    return normalized;
+}
+function modulo(value, divisor) {
+    return ((value % divisor) + divisor) % divisor;
+}

package/dist/dataGridColumnLayout.d.ts

@@ -0,0 +1 @@
+export * from "./config/dataGridColumnLayout";

package/dist/dataGridColumnLayout.js

@@ -0,0 +1 @@
+export * from "./config/dataGridColumnLayout";

package/dist/dataGridColumnMenu.d.ts

@@ -0,0 +1,9 @@
+export interface DataGridColumnMenuOptions {
+    enabled: boolean;
+    maxFilterValues: number;
+}
+export type DataGridColumnMenuProp = boolean | {
+    enabled?: boolean;
+    maxFilterValues?: number;
+} | null;
+export declare function resolveDataGridColumnMenu(input: DataGridColumnMenuProp | undefined): DataGridColumnMenuOptions;

package/dist/dataGridColumnMenu.js

@@ -0,0 +1,21 @@
+const DEFAULT_MAX_FILTER_VALUES = 120;
+export function resolveDataGridColumnMenu(input) {
+    if (typeof input === "boolean") {
+        return {
+            enabled: input,
+            maxFilterValues: DEFAULT_MAX_FILTER_VALUES,
+        };
+    }
+    if (!input) {
+        return {
+            enabled: false,
+            maxFilterValues: DEFAULT_MAX_FILTER_VALUES,
+        };
+    }
+    return {
+        enabled: input.enabled ?? true,
+        maxFilterValues: Number.isFinite(input.maxFilterValues)
+            ? Math.max(20, Math.trunc(input.maxFilterValues))
+            : DEFAULT_MAX_FILTER_VALUES,
+    };
+}

package/dist/dataGridEditability.d.ts

@@ -0,0 +1,9 @@
+import type { DataGridColumnSnapshot, DataGridRowId } from "@affino/datagrid-vue";
+export interface DataGridCellEditablePredicateContext<TRow> {
+    row: TRow;
+    rowId: DataGridRowId;
+    rowIndex: number;
+    column: DataGridColumnSnapshot["column"];
+    columnKey: string;
+}
+export type DataGridCellEditablePredicate<TRow> = (ctx: DataGridCellEditablePredicateContext<TRow>) => boolean;

package/dist/dataGridEditability.js

@@ -0,0 +1 @@
+export {};

package/dist/dataGridFilterableCombobox.d.ts

@@ -0,0 +1 @@
+export * from "./overlays/dataGridFilterableCombobox";

package/dist/dataGridFilterableCombobox.js

@@ -0,0 +1 @@
+export * from "./overlays/dataGridFilterableCombobox";

package/dist/dataGridFormulaOptions.d.ts

@@ -0,0 +1 @@
+export * from "./config/dataGridFormulaOptions";

package/dist/dataGridFormulaOptions.js

@@ -0,0 +1 @@
+export * from "./config/dataGridFormulaOptions";

package/dist/dataGridGantt.d.ts

@@ -0,0 +1,3 @@
+export type DataGridAppViewMode = "table" | "gantt";
+export { DAY_MS, addDataGridWorkingDays, applyDataGridGanttDragDelta, buildDataGridGanttDependencyPaths, buildDataGridGanttRowEditPatch, buildDataGridNonWorkingDaySpans, buildDataGridTimelineModel, buildDataGridTimelineRenderModels, buildDataGridGanttVisibleBars, clampDataGridGanttScrollLeft, clampDataGridTimelineScrollLeft, formatDataGridGanttDayLabel, hitTestDataGridGanttBar, isDataGridWorkingDay, normalizeDataGridGanttOptions, resolveDataGridGanttDateOffset, resolveDataGridGanttDateMs, resolveDataGridGanttDependencies, resolveDataGridGanttDependencyRefs, resolveDataGridGanttProgress, resolveDataGridGanttRangeFrame, resolveDataGridGanttSnapDays, resolveDataGridGanttCriticalTaskIds, resolveDataGridGanttScrollLeftForDate, resolveDataGridGanttTimelineState, resolveDataGridWorkingCalendar, snapDataGridGanttDateMs, snapDataGridGanttDayDelta, snapDataGridDateToWorkingDay, startOfUtcDay, startOfUtcWeek, resolveDataGridTimelineDateToPixel, resolveDataGridTimelinePixelToDate, resolveDataGridTimelineRange, resolveDataGridTimelineScrollLeftForDate, resolveDataGridTimelineViewport, } from "@affino/datagrid-gantt";
+export type { BuildDataGridGanttDependencyPathsInput, BuildDataGridGanttVisibleBarsInput, BuildDataGridTimelineModelInput, BuildDataGridTimelineRenderModelsInput, DataGridGanttBarFrame, DataGridGanttBarLayout, DataGridGanttCriticalTaskNode, DataGridGanttDependencyPath, DataGridGanttDependencyRef, DataGridGanttDependencyType, DataGridGanttDependencyValue, DataGridGanttDragRange, DataGridGanttHorizontalAlign, DataGridGanttHitMode, DataGridGanttHitTarget, DataGridGanttOptions, DataGridGanttProp, DataGridGanttRowEditPatch, DataGridGanttRowReader, DataGridGanttTimelineState, DataGridGanttZoomLevel, DataGridResolvedGanttOptions, DataGridResolvedWorkingCalendar, DataGridTimelineHorizontalAlign, DataGridTimelineLine, DataGridTimelineModel, DataGridTimelineRange, DataGridTimelineRenderModels, DataGridTimelineSegment, DataGridTimelineSpan, DataGridTimelineViewport, DataGridWorkingCalendar, ResolveDataGridTimelineRangeInput, } from "@affino/datagrid-gantt";

package/dist/dataGridGantt.js

@@ -0,0 +1 @@
+export { DAY_MS, addDataGridWorkingDays, applyDataGridGanttDragDelta, buildDataGridGanttDependencyPaths, buildDataGridGanttRowEditPatch, buildDataGridNonWorkingDaySpans, buildDataGridTimelineModel, buildDataGridTimelineRenderModels, buildDataGridGanttVisibleBars, clampDataGridGanttScrollLeft, clampDataGridTimelineScrollLeft, formatDataGridGanttDayLabel, hitTestDataGridGanttBar, isDataGridWorkingDay, normalizeDataGridGanttOptions, resolveDataGridGanttDateOffset, resolveDataGridGanttDateMs, resolveDataGridGanttDependencies, resolveDataGridGanttDependencyRefs, resolveDataGridGanttProgress, resolveDataGridGanttRangeFrame, resolveDataGridGanttSnapDays, resolveDataGridGanttCriticalTaskIds, resolveDataGridGanttScrollLeftForDate, resolveDataGridGanttTimelineState, resolveDataGridWorkingCalendar, snapDataGridGanttDateMs, snapDataGridGanttDayDelta, snapDataGridDateToWorkingDay, startOfUtcDay, startOfUtcWeek, resolveDataGridTimelineDateToPixel, resolveDataGridTimelinePixelToDate, resolveDataGridTimelineRange, resolveDataGridTimelineScrollLeftForDate, resolveDataGridTimelineViewport, } from "@affino/datagrid-gantt";

package/dist/dataGridGanttDependencySelection.d.ts

@@ -0,0 +1,7 @@
+import type { DataGridGanttDependencyPath } from "./dataGridGantt";
+export declare const DATAGRID_GANTT_DEPENDENCY_HIT_SLOP_PX = 6;
+export declare function resolveDataGridGanttDependencyPathKey<TRow>(path: Pick<DataGridGanttDependencyPath<TRow>, "dependencyTaskId" | "dependencyType" | "sourceBar" | "targetBar">): string;
+export declare function hitTestDataGridGanttDependencyPath<TRow>(paths: readonly DataGridGanttDependencyPath<TRow>[], point: {
+    x: number;
+    y: number;
+}, hitSlopPx?: number): DataGridGanttDependencyPath<TRow> | null;

package/dist/dataGridGanttDependencySelection.js

@@ -0,0 +1,46 @@
+export const DATAGRID_GANTT_DEPENDENCY_HIT_SLOP_PX = 6;
+export function resolveDataGridGanttDependencyPathKey(path) {
+    return [
+        path.dependencyTaskId,
+        path.dependencyType,
+        path.sourceBar.rowId,
+        path.targetBar.rowId,
+    ].join("::");
+}
+function resolveSquaredDistanceToSegment(point, start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    if (dx === 0 && dy === 0) {
+        const distanceX = point.x - start.x;
+        const distanceY = point.y - start.y;
+        return (distanceX * distanceX) + (distanceY * distanceY);
+    }
+    const projection = (((point.x - start.x) * dx) + ((point.y - start.y) * dy)) / ((dx * dx) + (dy * dy));
+    const clampedProjection = Math.max(0, Math.min(1, projection));
+    const closestX = start.x + (dx * clampedProjection);
+    const closestY = start.y + (dy * clampedProjection);
+    const distanceX = point.x - closestX;
+    const distanceY = point.y - closestY;
+    return (distanceX * distanceX) + (distanceY * distanceY);
+}
+export function hitTestDataGridGanttDependencyPath(paths, point, hitSlopPx = DATAGRID_GANTT_DEPENDENCY_HIT_SLOP_PX) {
+    const maxDistanceSquared = Math.max(1, hitSlopPx) ** 2;
+    let bestPath = null;
+    let bestDistanceSquared = Number.POSITIVE_INFINITY;
+    for (const path of paths) {
+        for (let pointIndex = 1; pointIndex < path.points.length; pointIndex += 1) {
+            const start = path.points[pointIndex - 1];
+            const end = path.points[pointIndex];
+            if (!start || !end) {
+                continue;
+            }
+            const distanceSquared = resolveSquaredDistanceToSegment(point, start, end);
+            if (distanceSquared > maxDistanceSquared || distanceSquared >= bestDistanceSquared) {
+                continue;
+            }
+            bestDistanceSquared = distanceSquared;
+            bestPath = path;
+        }
+    }
+    return bestPath;
+}

package/dist/dataGridGanttLabel.d.ts

@@ -0,0 +1,2 @@
+export declare const DATAGRID_GANTT_MIN_INLINE_LABEL_WIDTH_PX = 44;
+export declare function resolveDataGridGanttInlineLabel(label: string, availableWidth: number, measureTextWidth: (text: string) => number): string | null;

package/dist/dataGridGanttLabel.js

@@ -0,0 +1,30 @@
+export const DATAGRID_GANTT_MIN_INLINE_LABEL_WIDTH_PX = 44;
+export function resolveDataGridGanttInlineLabel(label, availableWidth, measureTextWidth) {
+    const normalizedLabel = label.trim();
+    if (normalizedLabel.length === 0 || availableWidth < DATAGRID_GANTT_MIN_INLINE_LABEL_WIDTH_PX) {
+        return null;
+    }
+    if (measureTextWidth(normalizedLabel) <= availableWidth) {
+        return normalizedLabel;
+    }
+    const ellipsis = "...";
+    const ellipsisWidth = measureTextWidth(ellipsis);
+    if (ellipsisWidth > availableWidth) {
+        return null;
+    }
+    let low = 0;
+    let high = normalizedLabel.length;
+    let fitted = "";
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const candidate = `${normalizedLabel.slice(0, middle).trimEnd()}${ellipsis}`;
+        if (measureTextWidth(candidate) <= availableWidth) {
+            fitted = candidate;
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return fitted.length > 0 ? fitted : null;
+}