1163 lines
34 KiB
JavaScript
1163 lines
34 KiB
JavaScript
/**
|
|
* @file shipmentAutomat.js
|
|
* @description Manages cached and chunk-paginated company shipment manifests (`GET /api/shipment`).
|
|
*
|
|
* Implements a multi-filter chunk cache identical to `orderAutomat`:
|
|
* - Each filter combination has its own isolated cache entry (total, unfilteredTotal, items array, loadedChunks).
|
|
* - Total chunk capacity across all filter combinations is bounded by a global LRU limit of 50 chunks.
|
|
* - When filter settings change, previously loaded chunks remain cached in memory up to the 50-chunk limit.
|
|
* - Switching back to a previously used filter is instant with zero network requests if its chunks are in RAM.
|
|
* - Supports chunked pagination via `requireChunk(chunkIndex)` and `loadChunk(chunkIndex)`.
|
|
*
|
|
* Upstream Triggers:
|
|
* - `authAutomat`: Triggers `actions.reset()` on `'anon'` or when `selectedCompanyId` changes.
|
|
* - `sseAutomat`: Triggers `actions.reload()` on `'shipment'` and `'order'` SSE events.
|
|
* - UI / Routes: Calls `getItems()`, `requireChunk(chunkIndex)`, `loadChunk(chunkIndex)`, or `reload()`.
|
|
*/
|
|
|
|
import { Automat } from 'react-automat';
|
|
import { shipment as shipmentApi } from '../api';
|
|
import authAutomat from './authAutomat';
|
|
import orderAutomat from './orderAutomat';
|
|
|
|
/**
|
|
* @typedef {Object} ShipmentSummary
|
|
* @property {number} id
|
|
* @property {string} number
|
|
* @property {'shipment'} type
|
|
* @property {string} date
|
|
* @property {string|null} createdAt
|
|
* @property {number|null} orderId
|
|
* @property {string|null} orderNumber
|
|
* @property {number|null} entityId
|
|
* @property {string|null} customerName
|
|
* @property {number} positions
|
|
* @property {number} totalQuantity
|
|
* @property {number} packageCount
|
|
* @property {string|null} carrier
|
|
* @property {string|null} trackingCode
|
|
* @property {'new'|'delivered'|'returned'} state
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} ShipmentAutomatState
|
|
* @property {ShipmentSummary[]|null} items Pre-filled array of shipments/nulls, initially null.
|
|
* @property {number} total Total unpaged count for pagination calculation.
|
|
* @property {number} unfilteredTotal Unfiltered total count.
|
|
* @property {string} filter Search term.
|
|
* @property {string} stateFilter Delivery state filter ('', 'new', 'delivered', 'returned').
|
|
* @property {number} seekMonths Seek month count.
|
|
* @property {number} seekYears Seek year count.
|
|
* @property {number} negativeSeekMonths Negative seek months offset.
|
|
* @property {'idle'|'loading'|'ready'|'failed'} status Load lifecycle state.
|
|
* @property {Error|string|null} error Last load error.
|
|
*/
|
|
|
|
export const CHUNK_SIZE = 50;
|
|
export const MAX_LRU_CHUNKS = 50;
|
|
const PREFETCH_CHUNKS = 1;
|
|
const CHUNK_DEBOUNCE_MS = 130;
|
|
|
|
const initialState = {
|
|
items: null,
|
|
total: 0,
|
|
unfilteredTotal: 0,
|
|
filter: '',
|
|
stateFilter: '',
|
|
entityId: null,
|
|
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();
|
|
|
|
// Dev / Observability: Chunk event history and subscriber registry
|
|
const MAX_CHUNK_EVENTS = 150;
|
|
let nextEventId = 0;
|
|
const chunkEvents = [];
|
|
const chunkStatsListeners = new Set();
|
|
|
|
export function makeLruKey(filterKey, chunkIndex) {
|
|
return `${filterKey}:::${chunkIndex}`;
|
|
}
|
|
|
|
export function parseLruKey(key) {
|
|
const [filterKey, chunkStr] = key.split(':::');
|
|
return { filterKey, chunkIndex: Number(chunkStr) };
|
|
}
|
|
|
|
// MARK: pure filter helpers
|
|
export function getFilterParams(state = automat?.state || initialState) {
|
|
const filter = String(state.filter ?? '').trim();
|
|
const stateFilter = String(state.stateFilter ?? '').trim();
|
|
const entityId = state.entityId != null && state.entityId !== '' ? Number(state.entityId) : null;
|
|
const negativeSeekMonths = (state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0)
|
|
? Number(state.negativeSeekMonths)
|
|
: 0;
|
|
return { filter, stateFilter, entityId, negativeSeekMonths };
|
|
}
|
|
|
|
export function getFilterKey(state = automat?.state || initialState) {
|
|
const { filter, stateFilter, entityId, negativeSeekMonths } = getFilterParams(state);
|
|
return JSON.stringify({ f: filter, st: stateFilter, e: entityId, s: negativeSeekMonths });
|
|
}
|
|
|
|
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(' ')}`;
|
|
}
|
|
|
|
export function formatFilterLabel(filterKeyOrState) {
|
|
let f, st, e, s;
|
|
if (typeof filterKeyOrState === 'string') {
|
|
try {
|
|
const parsed = JSON.parse(filterKeyOrState);
|
|
f = parsed.f;
|
|
st = parsed.st;
|
|
e = parsed.e;
|
|
s = parsed.s;
|
|
} catch {
|
|
return filterKeyOrState;
|
|
}
|
|
} else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
|
|
if ('f' in filterKeyOrState) {
|
|
f = filterKeyOrState.f;
|
|
st = filterKeyOrState.st;
|
|
e = filterKeyOrState.e;
|
|
s = filterKeyOrState.s;
|
|
} else {
|
|
const params = getFilterParams(filterKeyOrState);
|
|
f = params.filter;
|
|
st = params.stateFilter;
|
|
e = params.entityId;
|
|
s = params.negativeSeekMonths;
|
|
}
|
|
}
|
|
|
|
const parts = [];
|
|
if (f) parts.push(`Suche: „${f}“`);
|
|
if (e != null) parts.push(`Kunde: #${e}`);
|
|
if (st) parts.push(`Status: ${st}`);
|
|
if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
|
|
if (parts.length === 0) return 'Standard (Alle Lieferscheine)';
|
|
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, shipmentCount = 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,
|
|
shipmentCount,
|
|
});
|
|
|
|
while (lruChunks.size > MAX_LRU_CHUNKS) {
|
|
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 * CHUNK_SIZE;
|
|
for (let i = offset; i < offset + CHUNK_SIZE && i < entry.items.length; i++) {
|
|
entry.items[i] = null;
|
|
}
|
|
}
|
|
|
|
const currentKey = getFilterKey(automat.state);
|
|
if (filterKey === currentKey) {
|
|
automat.setState({ items: [...entry.items] });
|
|
}
|
|
|
|
const eventType = reason === 'lru' ? 'lru_evict' : 'evict';
|
|
const msg = reason === 'lru'
|
|
? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen (${lruChunks.size}/${MAX_LRU_CHUNKS} im Cache)`
|
|
: `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`;
|
|
|
|
recordChunkEvent({
|
|
type: eventType,
|
|
chunkIndex,
|
|
filterKey,
|
|
message: msg,
|
|
});
|
|
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('[shipmentAutomat] chunkStatsListener error', e);
|
|
}
|
|
}
|
|
}
|
|
|
|
export 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 chunkCount = total > 0 ? Math.ceil(total / CHUNK_SIZE) : (activeLoaded.size > 0 ? Math.max(...activeLoaded) + 1 : 0);
|
|
const items = activeEntry?.items ?? automat?.state?.items;
|
|
const loadedItemsCount = countNonNullItems(items);
|
|
|
|
const cachedFiltersSummary = Array.from(filterCaches.values()).map((entry) => ({
|
|
key: entry.key,
|
|
label: entry.label,
|
|
params: entry.params,
|
|
total: entry.total,
|
|
loadedChunksCount: entry.loadedChunks.size,
|
|
loadedChunks: Array.from(entry.loadedChunks).sort((a, b) => a - b),
|
|
chunkCount: entry.total > 0 ? Math.ceil(entry.total / CHUNK_SIZE) : (entry.loadedChunks.size > 0 ? Math.max(...entry.loadedChunks) + 1 : 0),
|
|
loadedItemsCount: countNonNullItems(entry.items),
|
|
lastAccessed: entry.lastAccessed,
|
|
isActive: entry.key === currentKey,
|
|
status: entry.status,
|
|
items: entry.items,
|
|
}));
|
|
|
|
const lruEntries = Array.from(lruChunks.entries()).map(([key, info], idx) => ({
|
|
lruKey: key,
|
|
filterKey: info.filterKey,
|
|
filterLabel: filterCaches.get(info.filterKey)?.label || info.filterKey,
|
|
chunkIndex: info.chunkIndex,
|
|
loadedAt: info.loadedAt,
|
|
accessedAt: info.accessedAt,
|
|
shipmentCount: info.shipmentCount,
|
|
lruRank: idx + 1,
|
|
}));
|
|
|
|
const activeInflight = [];
|
|
for (const key of inflightChunks.keys()) {
|
|
if (key.startsWith(`${currentKey}:::`)) {
|
|
const parsed = parseLruKey(key);
|
|
activeInflight.push(parsed.chunkIndex);
|
|
}
|
|
}
|
|
|
|
return {
|
|
automatName: 'shipment',
|
|
chunkSize: CHUNK_SIZE,
|
|
maxLruChunks: MAX_LRU_CHUNKS,
|
|
lruChunksCount: lruChunks.size,
|
|
total,
|
|
chunkCount,
|
|
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 ?? '',
|
|
stateFilter: automat?.state?.stateFilter ?? '',
|
|
seekMonths: automat?.state?.seekMonths ?? 0,
|
|
seekYears: automat?.state?.seekYears ?? 0,
|
|
negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
|
|
items,
|
|
activeFilterKey: currentKey,
|
|
activeFilterLabel: formatFilterLabel(currentKey),
|
|
filterCaches: cachedFiltersSummary,
|
|
lruEntries,
|
|
events: [...chunkEvents],
|
|
};
|
|
}
|
|
|
|
export 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 * CHUNK_SIZE >= 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 = CHUNK_SIZE) {
|
|
const params = { offset, limit };
|
|
const trimmed = String(filterParams.filter ?? '').trim();
|
|
if (trimmed) params.search = trimmed;
|
|
if (filterParams.stateFilter) params.state = filterParams.stateFilter;
|
|
if (filterParams.entityId != null) params.entityId = filterParams.entityId;
|
|
if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
|
|
params.seekMonths = Number(filterParams.negativeSeekMonths);
|
|
}
|
|
return params;
|
|
}
|
|
|
|
async function fetchShipmentsPageFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
|
|
const params = buildQueryParamsFor(filterParams, offset, limit);
|
|
const res = await shipmentApi.list(params);
|
|
const shipments = Array.isArray(res?.shipments) ? res.shipments : [];
|
|
const total = Number(res?.total ?? shipments.length);
|
|
const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
|
|
return { shipments, 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)} Lieferscheine 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 * CHUNK_SIZE;
|
|
const limit = CHUNK_SIZE;
|
|
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 = fetchShipmentsPageFor(filterParams, offset, limit)
|
|
.then(({ shipments, 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 < shipments.length; i++) {
|
|
const idx = offset + i;
|
|
if (idx < entry.items.length) {
|
|
entry.items[idx] = shipments[i];
|
|
}
|
|
}
|
|
|
|
entry.loadedChunks.add(index);
|
|
entry.status = 'ready';
|
|
entry.error = null;
|
|
entry.lastAccessed = Date.now();
|
|
|
|
registerChunkLRU(targetFilterKey, index, shipments.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: shipments.length,
|
|
duration,
|
|
message: `Chunk #${index} geladen (${shipments.length} Lieferscheine 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(`[shipmentAutomat] 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;
|
|
},
|
|
|
|
// MARK: server-side filter actions
|
|
filter(query) {
|
|
automat.setState({ filter: String(query ?? '') });
|
|
onFilterChange(false);
|
|
},
|
|
|
|
setFilter(query) {
|
|
actions.filter(query);
|
|
},
|
|
|
|
setStateFilter(stateFilter) {
|
|
automat.setState({ stateFilter: String(stateFilter ?? '') });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
setEntityId(entityId) {
|
|
const parsed = entityId != null && entityId !== '' ? Number(entityId) : null;
|
|
automat.setState({ entityId: parsed });
|
|
onFilterChange(true);
|
|
},
|
|
|
|
setSeekMonths(months) {
|
|
actions.addNegativeSeek(-months);
|
|
},
|
|
|
|
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: '',
|
|
stateFilter: '',
|
|
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;
|
|
|
|
recordChunkEvent({
|
|
type: 'replace',
|
|
filterKey: currentKey,
|
|
message: `Items ersetzt (${count} Einträge)`,
|
|
});
|
|
notifyChunkStats();
|
|
automat.setState({
|
|
items,
|
|
total: count,
|
|
status: 'ready',
|
|
error: null,
|
|
});
|
|
return items;
|
|
},
|
|
|
|
evictChunk(chunkIndex, filterKey = getFilterKey(automat.state)) {
|
|
const index = Math.max(0, Number(chunkIndex) || 0);
|
|
const key = makeLruKey(filterKey, index);
|
|
if (lruChunks.has(key)) {
|
|
lruChunks.delete(key);
|
|
}
|
|
evictChunkFromMemory(filterKey, index, 'manual');
|
|
return automat.state.items;
|
|
},
|
|
|
|
clearFilterCache(filterKey = getFilterKey(automat.state)) {
|
|
for (const [lruKey, info] of Array.from(lruChunks.entries())) {
|
|
if (info.filterKey === filterKey) {
|
|
lruChunks.delete(lruKey);
|
|
}
|
|
}
|
|
|
|
const entry = filterCaches.get(filterKey);
|
|
if (entry) {
|
|
entry.loadedChunks.clear();
|
|
entry.items = null;
|
|
entry.total = 0;
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
}
|
|
|
|
if (filterKey === getFilterKey(automat.state)) {
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
});
|
|
}
|
|
|
|
recordChunkEvent({
|
|
type: 'clear_filter',
|
|
filterKey,
|
|
message: `Filter-Cache für "${formatFilterLabel(filterKey)}" geleert`,
|
|
});
|
|
notifyChunkStats();
|
|
return automat.state.items;
|
|
},
|
|
|
|
clearCache() {
|
|
clearChunkDebounce();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
|
|
for (const entry of filterCaches.values()) {
|
|
entry.loadedChunks.clear();
|
|
entry.items = null;
|
|
entry.total = 0;
|
|
entry.status = 'idle';
|
|
entry.error = null;
|
|
}
|
|
|
|
automat.setState({
|
|
items: null,
|
|
total: 0,
|
|
status: 'idle',
|
|
error: null,
|
|
});
|
|
|
|
recordChunkEvent({
|
|
type: 'clear',
|
|
message: 'Gesamter LRU-Cache und alle Filter-Caches geleert',
|
|
});
|
|
notifyChunkStats();
|
|
return automat.state.items;
|
|
},
|
|
|
|
prefetchAllChunks(filterKey = getFilterKey(automat.state)) {
|
|
const entry = getOrCreateFilterCache(filterKey, automat.state);
|
|
const total = entry.total || automat.state.total || 0;
|
|
const chunkCount = Math.ceil(total / CHUNK_SIZE);
|
|
|
|
recordChunkEvent({
|
|
type: 'prefetch_all',
|
|
filterKey,
|
|
message: `Starte Prefetch aller ${chunkCount} Chunks für "${entry.label}"`,
|
|
});
|
|
|
|
for (let c = 0; c < chunkCount; c++) {
|
|
const inflightKey = makeLruKey(filterKey, c);
|
|
if (!entry.loadedChunks.has(c) && !inflightChunks.has(inflightKey)) {
|
|
void actions.loadChunk(c, queryEpoch, filterKey);
|
|
}
|
|
}
|
|
notifyChunkStats();
|
|
},
|
|
|
|
patchShipment(id, patch) {
|
|
let changed = false;
|
|
for (const entry of filterCaches.values()) {
|
|
if (Array.isArray(entry.items)) {
|
|
entry.items = entry.items.map((s) => {
|
|
if (s && s.id === id) {
|
|
changed = true;
|
|
return { ...s, ...patch };
|
|
}
|
|
return s;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(automat.state.items)) {
|
|
const items = automat.state.items.map((s) => {
|
|
if (s && s.id === id) {
|
|
changed = true;
|
|
return { ...s, ...patch };
|
|
}
|
|
return s;
|
|
});
|
|
if (changed) {
|
|
automat.setState({ items });
|
|
}
|
|
}
|
|
return automat.state.items;
|
|
},
|
|
|
|
async updateState(id, newState) {
|
|
actions.patchShipment(id, { state: newState });
|
|
try {
|
|
await shipmentApi.update(id, { state: newState });
|
|
void orderAutomat.actions.reload().catch(() => {});
|
|
} catch (err) {
|
|
void actions.reload();
|
|
throw err;
|
|
}
|
|
},
|
|
|
|
async deleteShipment(id) {
|
|
await shipmentApi.delete(id);
|
|
for (const entry of filterCaches.values()) {
|
|
if (Array.isArray(entry.items)) {
|
|
entry.items = entry.items.filter((item) => !item || item.id !== id);
|
|
entry.total = Math.max(0, entry.total - 1);
|
|
entry.unfilteredTotal = Math.max(0, entry.unfilteredTotal - 1);
|
|
}
|
|
}
|
|
automat.setState((s) => {
|
|
const items = Array.isArray(s.items) ? s.items.filter((item) => !item || item.id !== id) : s.items;
|
|
return {
|
|
items,
|
|
total: Math.max(0, s.total - 1),
|
|
unfilteredTotal: Math.max(0, s.unfilteredTotal - 1),
|
|
};
|
|
});
|
|
void orderAutomat.actions.reload().catch(() => {});
|
|
},
|
|
|
|
reset() {
|
|
queryEpoch++;
|
|
if (filterDebounceTimer) {
|
|
clearTimeout(filterDebounceTimer);
|
|
filterDebounceTimer = null;
|
|
}
|
|
clearChunkDebounce();
|
|
lruChunks.clear();
|
|
inflightChunks.clear();
|
|
filterCaches.clear();
|
|
chunkEvents.length = 0;
|
|
notifyChunkStats();
|
|
automat.setState({ ...initialState });
|
|
},
|
|
};
|
|
|
|
automat = new Automat(initialState, actions, { name: 'shipment' });
|
|
|
|
automat.getItems = actions.getItems;
|
|
automat.requireChunk = actions.requireChunk;
|
|
automat.CHUNK_SIZE = CHUNK_SIZE;
|
|
automat.MAX_LRU_CHUNKS = MAX_LRU_CHUNKS;
|
|
automat.getChunkStats = getChunkStats;
|
|
automat.subscribeChunkStats = subscribeChunkStats;
|
|
automat.evictChunk = actions.evictChunk;
|
|
automat.clearFilterCache = actions.clearFilterCache;
|
|
automat.clearCache = actions.clearCache;
|
|
automat.prefetchAllChunks = actions.prefetchAllChunks;
|
|
automat.getFilterKey = getFilterKey;
|
|
automat.formatFilterLabel = formatFilterLabel;
|
|
|
|
// #region authAutomat synchronization
|
|
let lastCompanyId = null;
|
|
authAutomat.subscribe((auth) => {
|
|
const companyId = auth.user?.selectedCompanyId ?? null;
|
|
if (auth.status === 'anon') {
|
|
automat.actions.reset();
|
|
lastCompanyId = null;
|
|
return;
|
|
}
|
|
if (lastCompanyId !== null && companyId !== lastCompanyId) {
|
|
automat.actions.reset();
|
|
}
|
|
if (auth.status === 'authed' && companyId != null) {
|
|
const isNew = lastCompanyId !== companyId;
|
|
lastCompanyId = companyId;
|
|
if (isNew) {
|
|
void automat.actions.load().catch(() => {});
|
|
}
|
|
}
|
|
});
|
|
|
|
if (authAutomat.state.status === 'authed' && authAutomat.state.user?.selectedCompanyId != null) {
|
|
lastCompanyId = authAutomat.state.user.selectedCompanyId;
|
|
void automat.actions.load().catch(() => {});
|
|
}
|
|
// #endregion
|
|
|
|
/** Selects current shipments */
|
|
export function selectShipments(state = automat.state) {
|
|
return state.items;
|
|
}
|
|
|
|
/** Selects total unpaged count */
|
|
export function selectShipmentTotal(state = automat.state) {
|
|
return state.total ?? 0;
|
|
}
|
|
|
|
/** Selects unfiltered total count */
|
|
export function selectShipmentUnfilteredTotal(state = automat.state) {
|
|
return state.unfilteredTotal ?? 0;
|
|
}
|
|
|
|
/** Selects state filter */
|
|
export function selectStateFilter(state = automat.state) {
|
|
return state.stateFilter;
|
|
}
|
|
|
|
/** Selects negative seek offset in months */
|
|
export function selectNegativeSeekMonths(state = automat.state) {
|
|
return state.negativeSeekMonths;
|
|
}
|
|
|
|
/** Selects seek month count */
|
|
export function selectSeekMonths(state = automat.state) {
|
|
return state.seekMonths ?? 0;
|
|
}
|
|
|
|
/** Selects seek year count */
|
|
export function selectSeekYears(state = automat.state) {
|
|
return state.seekYears ?? 0;
|
|
}
|
|
|
|
/**
|
|
* Calculates client pagination metadata.
|
|
*/
|
|
export function selectShipmentPagination(state = automat.state) {
|
|
const total = state.total ?? 0;
|
|
return {
|
|
total,
|
|
unfilteredTotal: state.unfilteredTotal ?? total,
|
|
offset: 0,
|
|
limit: CHUNK_SIZE,
|
|
currentPage: 1,
|
|
pageCount: Math.max(1, Math.ceil(total / CHUNK_SIZE)),
|
|
};
|
|
}
|
|
|
|
export default automat;
|