929 lines
28 KiB
JavaScript
929 lines
28 KiB
JavaScript
/**
|
|
* @file createChunkListAutomat.js
|
|
* @description Factory function for company-scoped, chunk-cached double-buffered
|
|
* list automats with LRU memory caching, debounced prefetching, and multi-filter
|
|
* retention (like `orderAutomat` and `quoteAutomat`).
|
|
*
|
|
* Upstream Triggers:
|
|
* - `authAutomat`: Subscribes each created automat to auth state — resets on `'anon'`
|
|
* or when `selectedCompanyId` changes.
|
|
* - Consumer UI (e.g. `FillSpace`): Calls `getItems()` and `requireChunk(start, end)`.
|
|
*/
|
|
|
|
import { Automat } from 'react-automat';
|
|
import authAutomat from './authAutomat';
|
|
|
|
export const DEFAULT_CHUNK_SIZE = 50;
|
|
export const DEFAULT_MAX_LRU_CHUNKS = 50;
|
|
const PREFETCH_CHUNKS = 1;
|
|
const CHUNK_DEBOUNCE_MS = 130;
|
|
const MAX_CHUNK_EVENTS = 150;
|
|
|
|
export function formatNegativeSeek(months) {
|
|
if (!months || months >= 0) return '';
|
|
const total = Math.abs(months);
|
|
const years = Math.floor(total / 12);
|
|
const remMonths = total % 12;
|
|
const parts = [];
|
|
if (years > 0) {
|
|
parts.push(`${years} ${years === 1 ? 'Jahr' : 'Jahre'}`);
|
|
}
|
|
if (remMonths > 0) {
|
|
parts.push(`${remMonths} ${remMonths === 1 ? 'Monat' : 'Monate'}`);
|
|
}
|
|
return `-${parts.join(' ')}`;
|
|
}
|
|
|
|
/**
|
|
* Creates a chunk-paginated, double-buffered automat.
|
|
*
|
|
* @param {object} options
|
|
* @param {string} options.name Name for the Automat instance.
|
|
* @param {(params: { offset: number, limit: number, search?: string, seekMonths?: number }) => Promise<{ items?: any[], history?: any[], rows?: any[], entries?: any[], total?: number, unfilteredTotal?: number }>} options.fetchPage
|
|
* @param {number} [options.chunkSize=50]
|
|
* @param {number} [options.maxLruChunks=50]
|
|
* @returns {Automat} Configured chunk-list automat.
|
|
*/
|
|
export function createChunkListAutomat({
|
|
name,
|
|
fetchPage,
|
|
chunkSize = DEFAULT_CHUNK_SIZE,
|
|
maxLruChunks = DEFAULT_MAX_LRU_CHUNKS,
|
|
}) {
|
|
const initialState = {
|
|
items: null,
|
|
total: 0,
|
|
unfilteredTotal: 0,
|
|
filter: '',
|
|
seekMonths: 0,
|
|
seekYears: 0,
|
|
negativeSeekMonths: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
};
|
|
|
|
let automat;
|
|
let queryEpoch = 0;
|
|
let filterDebounceTimer = null;
|
|
let chunkDebounceTimer = null;
|
|
let currentEventTick = 0;
|
|
let lastRequireChunkTick = -1;
|
|
|
|
const pendingTargetChunks = new Set();
|
|
let pendingChunkPromise = null;
|
|
let pendingChunkResolve = null;
|
|
let pendingChunkReject = null;
|
|
|
|
// Multi-Filter Cache & Global LRU Management
|
|
const filterCaches = new Map();
|
|
const lruChunks = new Map();
|
|
const inflightChunks = new Map();
|
|
|
|
// Observability & Stats
|
|
let nextEventId = 0;
|
|
const chunkEvents = [];
|
|
const chunkStatsListeners = new Set();
|
|
|
|
function makeLruKey(filterKey, chunkIndex) {
|
|
return `${filterKey}:::${chunkIndex}`;
|
|
}
|
|
|
|
function parseLruKey(key) {
|
|
const [filterKey, chunkStr] = key.split(':::');
|
|
return { filterKey, chunkIndex: Number(chunkStr) };
|
|
}
|
|
|
|
function getFilterParams(state = automat?.state || initialState) {
|
|
const filter = String(state.filter ?? '').trim();
|
|
const negativeSeekMonths =
|
|
state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0
|
|
? Number(state.negativeSeekMonths)
|
|
: 0;
|
|
return { filter, negativeSeekMonths };
|
|
}
|
|
|
|
function getFilterKey(state = automat?.state || initialState) {
|
|
const { filter, negativeSeekMonths } = getFilterParams(state);
|
|
return JSON.stringify({ f: filter, s: negativeSeekMonths });
|
|
}
|
|
|
|
function formatFilterLabel(filterKeyOrState) {
|
|
let f, s;
|
|
if (typeof filterKeyOrState === 'string') {
|
|
try {
|
|
const parsed = JSON.parse(filterKeyOrState);
|
|
f = parsed.f;
|
|
s = parsed.s;
|
|
} catch {
|
|
return filterKeyOrState;
|
|
}
|
|
} else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
|
|
if ('f' in filterKeyOrState) {
|
|
f = filterKeyOrState.f;
|
|
s = filterKeyOrState.s;
|
|
} else {
|
|
const params = getFilterParams(filterKeyOrState);
|
|
f = params.filter;
|
|
s = params.negativeSeekMonths;
|
|
}
|
|
}
|
|
|
|
const parts = [];
|
|
if (f) parts.push(`Suche: „${f}“`);
|
|
if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
|
|
if (parts.length === 0) return 'Standard (Alle Einträge)';
|
|
return parts.join(' · ');
|
|
}
|
|
|
|
function countNonNullItems(items) {
|
|
if (!Array.isArray(items)) return 0;
|
|
let count = 0;
|
|
for (let i = 0; i < items.length; i++) {
|
|
if (items[i] != null) count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
function getOrCreateFilterCache(filterKey, filterState = automat?.state || initialState) {
|
|
let entry = filterCaches.get(filterKey);
|
|
if (!entry) {
|
|
const params = getFilterParams(filterState);
|
|
entry = {
|
|
key: filterKey,
|
|
label: formatFilterLabel(params),
|
|
params,
|
|
total: 0,
|
|
unfilteredTotal: automat?.state?.unfilteredTotal || 0,
|
|
items: null,
|
|
loadedChunks: new Set(),
|
|
status: 'idle',
|
|
error: null,
|
|
lastAccessed: Date.now(),
|
|
epoch: queryEpoch,
|
|
};
|
|
filterCaches.set(filterKey, entry);
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
function touchChunkLRU(filterKey, chunkIndex) {
|
|
const key = makeLruKey(filterKey, chunkIndex);
|
|
const existing = lruChunks.get(key);
|
|
if (existing) {
|
|
lruChunks.delete(key);
|
|
lruChunks.set(key, { ...existing, accessedAt: Date.now() });
|
|
}
|
|
}
|
|
|
|
function registerChunkLRU(filterKey, chunkIndex, itemCount = 0) {
|
|
const key = makeLruKey(filterKey, chunkIndex);
|
|
if (lruChunks.has(key)) {
|
|
lruChunks.delete(key);
|
|
}
|
|
const now = Date.now();
|
|
lruChunks.set(key, {
|
|
filterKey,
|
|
chunkIndex,
|
|
loadedAt: now,
|
|
accessedAt: now,
|
|
itemCount,
|
|
});
|
|
|
|
while (lruChunks.size > maxLruChunks) {
|
|
const oldestKey = lruChunks.keys().next().value;
|
|
const oldestInfo = lruChunks.get(oldestKey);
|
|
lruChunks.delete(oldestKey);
|
|
if (oldestInfo) {
|
|
evictChunkFromMemory(oldestInfo.filterKey, oldestInfo.chunkIndex, 'lru');
|
|
}
|
|
}
|
|
}
|
|
|
|
function evictChunkFromMemory(filterKey, chunkIndex, reason = 'manual') {
|
|
const entry = filterCaches.get(filterKey);
|
|
if (!entry) return;
|
|
|
|
if (entry.loadedChunks.has(chunkIndex)) {
|
|
entry.loadedChunks.delete(chunkIndex);
|
|
if (Array.isArray(entry.items)) {
|
|
const offset = chunkIndex * chunkSize;
|
|
for (let i = offset; i < offset + chunkSize && i < entry.items.length; i++) {
|
|
entry.items[i] = null;
|
|
}
|
|
}
|
|
|
|
const currentKey = getFilterKey(automat.state);
|
|
if (filterKey === currentKey) {
|
|
automat.setState({ items: [...entry.items] });
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: reason === 'lru' ? 'lru_evict' : 'evict',
|
|
chunkIndex,
|
|
filterKey,
|
|
message:
|
|
reason === 'lru'
|
|
? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`
|
|
: `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`,
|
|
});
|
|
notifyChunkStats();
|
|
}
|
|
}
|
|
|
|
function recordChunkEvent(entry) {
|
|
const event = {
|
|
id: ++nextEventId,
|
|
time: Date.now(),
|
|
epoch: queryEpoch,
|
|
filterKey: entry.filterKey ?? getFilterKey(automat?.state),
|
|
...entry,
|
|
};
|
|
chunkEvents.push(event);
|
|
if (chunkEvents.length > MAX_CHUNK_EVENTS) {
|
|
chunkEvents.shift();
|
|
}
|
|
notifyChunkStats();
|
|
}
|
|
|
|
function notifyChunkStats() {
|
|
if (chunkStatsListeners.size === 0) return;
|
|
const stats = getChunkStats();
|
|
for (const listener of chunkStatsListeners) {
|
|
try {
|
|
listener(stats);
|
|
} catch (e) {
|
|
console.error(`[${name}] chunkStatsListener error`, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getChunkStats() {
|
|
const currentKey = getFilterKey(automat?.state);
|
|
const activeEntry = filterCaches.get(currentKey);
|
|
|
|
const total = activeEntry?.total ?? automat?.state?.total ?? 0;
|
|
const activeLoaded = activeEntry?.loadedChunks ?? new Set();
|
|
const count = total > 0 ? Math.ceil(total / chunkSize) : 0;
|
|
|
|
const activeInflight = [];
|
|
for (const key of inflightChunks.keys()) {
|
|
const info = parseLruKey(key);
|
|
if (info.filterKey === currentKey) {
|
|
activeInflight.push(info.chunkIndex);
|
|
}
|
|
}
|
|
|
|
const items = activeEntry?.items ?? automat?.state?.items ?? null;
|
|
const loadedItemsCount = countNonNullItems(items);
|
|
|
|
return {
|
|
chunkSize,
|
|
maxLruChunks,
|
|
lruChunksCount: lruChunks.size,
|
|
total,
|
|
unfilteredTotal: activeEntry?.unfilteredTotal ?? automat?.state?.unfilteredTotal ?? total,
|
|
chunkCount: count,
|
|
loadedChunks: Array.from(activeLoaded).sort((a, b) => a - b),
|
|
inflightChunks: activeInflight.sort((a, b) => a - b),
|
|
pendingChunks: Array.from(pendingTargetChunks).sort((a, b) => a - b),
|
|
loadedItemsCount,
|
|
status: automat?.state?.status ?? 'idle',
|
|
queryEpoch,
|
|
filter: automat?.state?.filter ?? '',
|
|
negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
|
|
items,
|
|
activeFilterKey: currentKey,
|
|
activeFilterLabel: formatFilterLabel(currentKey),
|
|
events: [...chunkEvents],
|
|
};
|
|
}
|
|
|
|
function subscribeChunkStats(listener) {
|
|
chunkStatsListeners.add(listener);
|
|
try {
|
|
listener(getChunkStats());
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
return () => {
|
|
chunkStatsListeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
function clearChunkDebounce() {
|
|
if (chunkDebounceTimer) {
|
|
clearTimeout(chunkDebounceTimer);
|
|
chunkDebounceTimer = null;
|
|
}
|
|
if (pendingTargetChunks.size > 0) {
|
|
pendingTargetChunks.clear();
|
|
notifyChunkStats();
|
|
}
|
|
pendingChunkPromise = null;
|
|
pendingChunkResolve = null;
|
|
pendingChunkReject = null;
|
|
}
|
|
|
|
function _executeRequiredChunks(
|
|
chunks,
|
|
targetEpoch,
|
|
prefetch = true,
|
|
targetFilterKey = getFilterKey(automat.state)
|
|
) {
|
|
if (targetEpoch !== queryEpoch) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
|
|
const chunkList = Array.from(chunks).sort((a, b) => a - b);
|
|
if (chunkList.length === 0) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'execute',
|
|
chunks: chunkList,
|
|
filterKey: targetFilterKey,
|
|
message: `Lade Chunks [${chunkList.join(', ')}] für "${formatFilterLabel(targetFilterKey)}" (Epoch ${targetEpoch})`,
|
|
});
|
|
|
|
const promises = [];
|
|
for (const c of chunkList) {
|
|
promises.push(actions.loadChunk(c, targetEpoch, targetFilterKey));
|
|
}
|
|
|
|
return Promise.all(promises).then(() => {
|
|
if (targetEpoch !== queryEpoch) return automat.state.items;
|
|
if (prefetch) {
|
|
const maxChunk = chunkList[chunkList.length - 1];
|
|
const entry = filterCaches.get(targetFilterKey);
|
|
const total = entry?.total || automat.state.total || 0;
|
|
for (let c = maxChunk + 1; c <= maxChunk + PREFETCH_CHUNKS; c++) {
|
|
if (total > 0 && c * chunkSize >= total) {
|
|
break;
|
|
}
|
|
recordChunkEvent({
|
|
type: 'prefetch',
|
|
chunkIndex: c,
|
|
filterKey: targetFilterKey,
|
|
message: `Prefetch Chunk #${c} für "${formatFilterLabel(targetFilterKey)}"`,
|
|
});
|
|
void actions.loadChunk(c, targetEpoch, targetFilterKey);
|
|
}
|
|
}
|
|
return automat.state.items;
|
|
});
|
|
}
|
|
|
|
function buildQueryParamsFor(filterParams, offset = 0, limit = chunkSize) {
|
|
const params = { offset, limit };
|
|
const trimmed = String(filterParams.filter ?? '').trim();
|
|
if (trimmed) params.search = trimmed;
|
|
if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
|
|
params.seekMonths = Number(filterParams.negativeSeekMonths);
|
|
}
|
|
return params;
|
|
}
|
|
|
|
async function fetchRecordsPageFor(filterParams, offset = 0, limit = chunkSize) {
|
|
const params = buildQueryParamsFor(filterParams, offset, limit);
|
|
const res = await fetchPage(params);
|
|
const records = Array.isArray(res?.items)
|
|
? res.items
|
|
: Array.isArray(res?.history)
|
|
? res.history
|
|
: Array.isArray(res?.ledger)
|
|
? res.ledger
|
|
: Array.isArray(res?.rows)
|
|
? res.rows
|
|
: Array.isArray(res?.entries)
|
|
? res.entries
|
|
: Array.isArray(res)
|
|
? res
|
|
: [];
|
|
const total = Number(res?.total ?? res?.totalRows ?? res?.totalCount ?? records.length);
|
|
const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
|
|
return { records, total, unfilteredTotal };
|
|
}
|
|
|
|
function onFilterChange(immediate = false) {
|
|
if (filterDebounceTimer) {
|
|
clearTimeout(filterDebounceTimer);
|
|
filterDebounceTimer = null;
|
|
}
|
|
if (immediate) {
|
|
applyFilterReload();
|
|
} else {
|
|
filterDebounceTimer = setTimeout(() => {
|
|
filterDebounceTimer = null;
|
|
applyFilterReload();
|
|
}, 200);
|
|
}
|
|
}
|
|
|
|
function applyFilterReload() {
|
|
queryEpoch++;
|
|
clearChunkDebounce();
|
|
|
|
const currentKey = getFilterKey(automat.state);
|
|
const cached = filterCaches.get(currentKey);
|
|
|
|
if (cached && cached.items !== null) {
|
|
cached.lastAccessed = Date.now();
|
|
for (const c of cached.loadedChunks) {
|
|
touchChunkLRU(currentKey, c);
|
|
}
|
|
|
|
automat.setState({
|
|
items: cached.items,
|
|
total: cached.total,
|
|
unfilteredTotal: cached.unfilteredTotal ?? automat.state.unfilteredTotal ?? 0,
|
|
status: cached.status || 'ready',
|
|
error: cached.error || null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'filter_hit',
|
|
epoch: queryEpoch,
|
|
filterKey: currentKey,
|
|
message: `Filter gewechselt: "${cached.label}" (Cache-Hit: ${cached.loadedChunks.size} Chunks / ${countNonNullItems(cached.items)} Einträge im RAM)`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
if (!cached.loadedChunks.has(0)) {
|
|
void actions.loadChunk(0, queryEpoch, currentKey);
|
|
}
|
|
} else {
|
|
const entry = getOrCreateFilterCache(currentKey, automat.state);
|
|
entry.lastAccessed = Date.now();
|
|
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
unfilteredTotal: automat.state.unfilteredTotal ?? 0,
|
|
status: 'loading',
|
|
error: null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'filter_miss',
|
|
epoch: queryEpoch,
|
|
filterKey: currentKey,
|
|
message: `Filter gewechselt: "${entry.label}" (Cache-Miss: Lade Chunk #0)`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
void actions.loadChunk(0, queryEpoch, currentKey);
|
|
}
|
|
}
|
|
|
|
const actions = {
|
|
getItems() {
|
|
if (automat.state.items === null) {
|
|
void actions.requireChunk(0, 0, { prefetch: false, immediate: true });
|
|
return null;
|
|
}
|
|
return automat.state.items;
|
|
},
|
|
|
|
requireChunk(chunkIndex, endOrOptions = chunkIndex, maybeOptions = {}) {
|
|
let start;
|
|
let end;
|
|
let options = {};
|
|
|
|
if (Array.isArray(chunkIndex)) {
|
|
start = chunkIndex[0] ?? 0;
|
|
end = chunkIndex[chunkIndex.length - 1] ?? start;
|
|
if (typeof endOrOptions === 'object' && endOrOptions !== null) {
|
|
options = endOrOptions;
|
|
}
|
|
} else {
|
|
start = Number(chunkIndex) || 0;
|
|
if (typeof endOrOptions === 'object' && endOrOptions !== null) {
|
|
end = start;
|
|
options = endOrOptions;
|
|
} else {
|
|
end = Number(endOrOptions ?? start) || start;
|
|
if (typeof maybeOptions === 'object' && maybeOptions !== null) {
|
|
options = maybeOptions;
|
|
}
|
|
}
|
|
}
|
|
|
|
start = Math.max(0, Math.floor(start));
|
|
end = Math.max(start, Math.floor(end));
|
|
const prefetch = options.prefetch !== false;
|
|
const currentKey = getFilterKey(automat.state);
|
|
|
|
if (options.immediate || automat.state.items === null) {
|
|
clearChunkDebounce();
|
|
const chunks = new Set();
|
|
for (let c = start; c <= end; c++) chunks.add(c);
|
|
recordChunkEvent({
|
|
type: 'require_immediate',
|
|
chunks: Array.from(chunks),
|
|
filterKey: currentKey,
|
|
message: `Sofortige Anforderung: Chunks ${start}..${end} (${formatFilterLabel(currentKey)})`,
|
|
});
|
|
return _executeRequiredChunks(chunks, queryEpoch, prefetch, currentKey);
|
|
}
|
|
|
|
if (lastRequireChunkTick !== currentEventTick) {
|
|
pendingTargetChunks.clear();
|
|
lastRequireChunkTick = currentEventTick;
|
|
if (typeof queueMicrotask === 'function') {
|
|
queueMicrotask(() => {
|
|
currentEventTick++;
|
|
});
|
|
} else {
|
|
Promise.resolve().then(() => {
|
|
currentEventTick++;
|
|
});
|
|
}
|
|
}
|
|
|
|
for (let c = start; c <= end; c++) {
|
|
pendingTargetChunks.add(c);
|
|
}
|
|
recordChunkEvent({
|
|
type: 'pending',
|
|
chunks: Array.from(pendingTargetChunks),
|
|
filterKey: currentKey,
|
|
message: `Debounce vorgemerkt (${CHUNK_DEBOUNCE_MS}ms): Chunks [${Array.from(pendingTargetChunks).join(', ')}]`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
if (chunkDebounceTimer) {
|
|
clearTimeout(chunkDebounceTimer);
|
|
chunkDebounceTimer = null;
|
|
}
|
|
|
|
if (!pendingChunkPromise) {
|
|
pendingChunkPromise = new Promise((resolve, reject) => {
|
|
pendingChunkResolve = resolve;
|
|
pendingChunkReject = reject;
|
|
});
|
|
}
|
|
|
|
const captureEpoch = queryEpoch;
|
|
chunkDebounceTimer = setTimeout(() => {
|
|
chunkDebounceTimer = null;
|
|
const chunksToLoad = new Set(pendingTargetChunks);
|
|
pendingTargetChunks.clear();
|
|
notifyChunkStats();
|
|
|
|
const resolve = pendingChunkResolve;
|
|
const reject = pendingChunkReject;
|
|
pendingChunkPromise = null;
|
|
pendingChunkResolve = null;
|
|
pendingChunkReject = null;
|
|
|
|
recordChunkEvent({
|
|
type: 'debounce_fire',
|
|
chunks: Array.from(chunksToLoad),
|
|
filterKey: currentKey,
|
|
message: `Debounce abgelaufen: Starte Chunks [${Array.from(chunksToLoad).join(', ')}]`,
|
|
});
|
|
|
|
_executeRequiredChunks(chunksToLoad, captureEpoch, true, currentKey)
|
|
.then((res) => resolve?.(res))
|
|
.catch((err) => reject?.(err));
|
|
}, CHUNK_DEBOUNCE_MS);
|
|
|
|
return pendingChunkPromise;
|
|
},
|
|
|
|
loadChunk(chunkIndex, targetEpoch = queryEpoch, targetFilterKey = getFilterKey(automat.state)) {
|
|
const index = Math.max(0, Number(chunkIndex) || 0);
|
|
const entry = getOrCreateFilterCache(targetFilterKey, automat.state);
|
|
|
|
if (targetEpoch !== queryEpoch && targetFilterKey !== getFilterKey(automat.state)) {
|
|
return Promise.resolve(entry.items);
|
|
}
|
|
|
|
if (entry.loadedChunks.has(index)) {
|
|
touchChunkLRU(targetFilterKey, index);
|
|
recordChunkEvent({
|
|
type: 'hit',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Cache-Hit: Chunk #${index} für Filter "${entry.label}" bereits im Speicher`,
|
|
});
|
|
return Promise.resolve(
|
|
targetFilterKey === getFilterKey(automat.state) ? automat.state.items : entry.items
|
|
);
|
|
}
|
|
|
|
const inflightKey = makeLruKey(targetFilterKey, index);
|
|
if (inflightChunks.has(inflightKey)) {
|
|
recordChunkEvent({
|
|
type: 'inflight_hit',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Inflight-Hit: Chunk #${index} für Filter "${entry.label}" lädt bereits`,
|
|
});
|
|
return inflightChunks.get(inflightKey);
|
|
}
|
|
|
|
const offset = index * chunkSize;
|
|
const limit = chunkSize;
|
|
const isActiveFilter = targetFilterKey === getFilterKey(automat.state);
|
|
|
|
if (index === 0 && (entry.items === null || (isActiveFilter && automat.state.items === null))) {
|
|
entry.status = 'loading';
|
|
entry.error = null;
|
|
if (isActiveFilter) {
|
|
automat.setState({ status: 'loading', error: null });
|
|
}
|
|
}
|
|
|
|
const startTime = Date.now();
|
|
recordChunkEvent({
|
|
type: 'start',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
message: `Netzwerk-Request: Lade Chunk #${index} (Offset ${offset}..${offset + limit - 1}) für "${entry.label}"`,
|
|
});
|
|
|
|
const filterParams = entry.params || getFilterParams(automat.state);
|
|
const promise = fetchRecordsPageFor(filterParams, offset, limit)
|
|
.then(({ records, total, unfilteredTotal }) => {
|
|
const currentTotal = total > 0 ? total : 0;
|
|
entry.total = currentTotal;
|
|
entry.unfilteredTotal = unfilteredTotal;
|
|
|
|
if (entry.items === null || entry.items.length !== currentTotal) {
|
|
entry.items = new Array(currentTotal).fill(null);
|
|
} else {
|
|
entry.items = [...entry.items];
|
|
}
|
|
|
|
for (let i = 0; i < records.length; i++) {
|
|
const idx = offset + i;
|
|
if (idx < entry.items.length) {
|
|
entry.items[idx] = records[i];
|
|
}
|
|
}
|
|
|
|
entry.loadedChunks.add(index);
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
entry.lastAccessed = Date.now();
|
|
|
|
registerChunkLRU(targetFilterKey, index, records.length);
|
|
|
|
const currentActive = targetFilterKey === getFilterKey(automat.state);
|
|
if (currentActive) {
|
|
automat.setState({
|
|
items: entry.items,
|
|
total: currentTotal,
|
|
unfilteredTotal,
|
|
status: 'ready',
|
|
error: null,
|
|
});
|
|
}
|
|
|
|
const duration = Date.now() - startTime;
|
|
recordChunkEvent({
|
|
type: 'loaded',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
count: records.length,
|
|
duration,
|
|
message: `Chunk #${index} geladen (${records.length} Einträge in ${duration}ms) für "${entry.label}"`,
|
|
});
|
|
|
|
return currentActive ? automat.state.items : entry.items;
|
|
})
|
|
.catch((err) => {
|
|
entry.status = 'failed';
|
|
entry.error = err;
|
|
const currentActive = targetFilterKey === getFilterKey(automat.state);
|
|
if (currentActive) {
|
|
if (index === 0 && automat.state.items === null) {
|
|
automat.setState({ status: 'failed', error: err });
|
|
}
|
|
}
|
|
const duration = Date.now() - startTime;
|
|
console.error(`[${name}] loadChunk(${index}, ${targetFilterKey}) error:`, err);
|
|
recordChunkEvent({
|
|
type: 'error',
|
|
chunkIndex: index,
|
|
filterKey: targetFilterKey,
|
|
duration,
|
|
error: err?.message || String(err),
|
|
message: `Fehler bei Chunk #${index} ("${entry.label}"): ${err?.message || err}`,
|
|
});
|
|
throw err;
|
|
})
|
|
.finally(() => {
|
|
inflightChunks.delete(inflightKey);
|
|
notifyChunkStats();
|
|
});
|
|
|
|
inflightChunks.set(inflightKey, promise);
|
|
notifyChunkStats();
|
|
return promise;
|
|
},
|
|
|
|
filter(query) {
|
|
automat.setState({ filter: String(query ?? '') });
|
|
onFilterChange(false);
|
|
},
|
|
|
|
addSeekMonth() {
|
|
const seekMonths = (automat.state.seekMonths ?? 0) + 1;
|
|
const seekYears = automat.state.seekYears ?? 0;
|
|
const totalMonths = -(seekMonths + seekYears * 12);
|
|
automat.setState({ seekMonths, negativeSeekMonths: totalMonths });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
addSeekYear() {
|
|
const seekMonths = automat.state.seekMonths ?? 0;
|
|
const seekYears = (automat.state.seekYears ?? 0) + 1;
|
|
const totalMonths = -(seekMonths + seekYears * 12);
|
|
automat.setState({ seekYears, negativeSeekMonths: totalMonths });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
addNegativeSeek(months) {
|
|
if (months === -12) {
|
|
actions.addSeekYear();
|
|
} else if (months === -1) {
|
|
actions.addSeekMonth();
|
|
} else {
|
|
const current = Math.min(0, Number(automat.state.negativeSeekMonths ?? 0));
|
|
const next = current + months;
|
|
automat.setState({ negativeSeekMonths: Math.min(0, next) });
|
|
onFilterChange(true);
|
|
}
|
|
},
|
|
|
|
resetNegativeSeek() {
|
|
automat.setState({ seekMonths: 0, seekYears: 0, negativeSeekMonths: 0 });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
resetFilters() {
|
|
automat.setState({
|
|
filter: '',
|
|
seekMonths: 0,
|
|
seekYears: 0,
|
|
negativeSeekMonths: 0,
|
|
});
|
|
onFilterChange(true);
|
|
},
|
|
|
|
load() {
|
|
return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
},
|
|
|
|
ensureLoaded() {
|
|
if (automat.state.items !== null) {
|
|
return Promise.resolve(automat.state.items);
|
|
}
|
|
return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
},
|
|
|
|
async reload(onlyCurrent = false) {
|
|
queryEpoch++;
|
|
clearChunkDebounce();
|
|
|
|
if (onlyCurrent) {
|
|
const currentKey = getFilterKey(automat.state);
|
|
actions.clearFilterCache(currentKey);
|
|
} else {
|
|
actions.clearCache();
|
|
}
|
|
|
|
await actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
|
|
return automat.state.items;
|
|
},
|
|
|
|
replace(items) {
|
|
clearChunkDebounce();
|
|
const currentKey = getFilterKey(automat.state);
|
|
actions.clearFilterCache(currentKey);
|
|
|
|
const count = Array.isArray(items) ? items.length : 0;
|
|
const entry = getOrCreateFilterCache(currentKey, automat.state);
|
|
entry.items = items;
|
|
entry.total = count;
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
|
|
const chunkCount = count > 0 ? Math.ceil(count / chunkSize) : 0;
|
|
for (let c = 0; c < chunkCount; c++) {
|
|
entry.loadedChunks.add(c);
|
|
registerChunkLRU(currentKey, c, Math.min(chunkSize, count - c * chunkSize));
|
|
}
|
|
|
|
automat.setState({
|
|
items,
|
|
total: count,
|
|
unfilteredTotal: count,
|
|
status: 'ready',
|
|
error: null,
|
|
});
|
|
notifyChunkStats();
|
|
},
|
|
|
|
clearFilterCache(filterKey) {
|
|
const entry = filterCaches.get(filterKey);
|
|
if (entry) {
|
|
for (const c of entry.loadedChunks) {
|
|
lruChunks.delete(makeLruKey(filterKey, c));
|
|
}
|
|
entry.items = null;
|
|
entry.loadedChunks.clear();
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
|
|
if (filterKey === getFilterKey(automat.state)) {
|
|
automat.setState({ items: null, status: 'idle', error: null });
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'clear_filter',
|
|
filterKey,
|
|
message: `Filter-Cache "${entry.label}" geleert`,
|
|
});
|
|
notifyChunkStats();
|
|
}
|
|
},
|
|
|
|
clearCache() {
|
|
clearChunkDebounce();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
|
|
for (const entry of filterCaches.values()) {
|
|
entry.items = null;
|
|
entry.loadedChunks.clear();
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'clear_all',
|
|
message: `Gesamter ${name}-Chunk-Cache geleert`,
|
|
});
|
|
notifyChunkStats();
|
|
|
|
automat.setState({
|
|
items: null,
|
|
status: 'idle',
|
|
error: null,
|
|
});
|
|
},
|
|
|
|
reset() {
|
|
if (filterDebounceTimer) {
|
|
clearTimeout(filterDebounceTimer);
|
|
filterDebounceTimer = null;
|
|
}
|
|
clearChunkDebounce();
|
|
filterCaches.clear();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
|
|
recordChunkEvent({
|
|
type: 'reset',
|
|
message: `${name}-Automat und sämtliche Caches zurückgesetzt`,
|
|
});
|
|
notifyChunkStats();
|
|
automat.setState(initialState);
|
|
},
|
|
};
|
|
|
|
automat = new Automat(initialState, actions, { name });
|
|
|
|
automat.getItems = actions.getItems;
|
|
automat.requireChunk = actions.requireChunk;
|
|
automat.CHUNK_SIZE = chunkSize;
|
|
automat.MAX_LRU_CHUNKS = maxLruChunks;
|
|
automat.getChunkStats = getChunkStats;
|
|
automat.subscribeChunkStats = subscribeChunkStats;
|
|
automat.getFilterKey = getFilterKey;
|
|
automat.formatFilterLabel = formatFilterLabel;
|
|
|
|
// Reset on logout or company change
|
|
let lastCompanyId = null;
|
|
authAutomat.subscribe((auth) => {
|
|
const companyId = auth.user?.selectedCompanyId ?? null;
|
|
if (auth.status === 'anon') {
|
|
actions.reset();
|
|
lastCompanyId = null;
|
|
return;
|
|
}
|
|
if (lastCompanyId !== null && companyId !== lastCompanyId) {
|
|
actions.reset();
|
|
}
|
|
if (auth.status === 'authed' && companyId != null) {
|
|
lastCompanyId = companyId;
|
|
}
|
|
});
|
|
|
|
return automat;
|
|
}
|