23789194950

Committed 31 Mar 2026 08:56AM UTC coverage: 74.971% (-8.3%) from 83.221%

Build # 23789194950

Build Type

push

github

Committed by

cr15p1

Commit Message

chore(release): bump prerelease to 0.29.0-rc.11 via changeset

Coverage Stats

947 of 1238 branches covered (76.49%)

Branch coverage included in aggregate %.

4235 of 5674 relevant lines covered (74.64%)

25.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/packages/sync/src/utils/runContextEntryCache.ts

export interface CreateRunContextEntryCacheInput<TPayload, TEntry> {
  createEntry: (payload: TPayload) => TEntry;
  limit: number;
}

export interface RunContextEntryCache<TPayload, TEntry> {
  getOrCreate: (payload: TPayload) => TEntry;
  clear: () => void;
}

interface ObjectRunContextEntry<TPayload extends object, TEntry> {
  payload: TPayload;
  entry: TEntry;
}

const MIN_PRIMITIVE_CACHE_LIMIT = 1;

const resolvePrimitiveCacheLimit = (limit: number): number => {
  if (!Number.isFinite(limit)) {
    return MIN_PRIMITIVE_CACHE_LIMIT;
  }

  const normalizedLimit = Math.floor(limit);
  if (normalizedLimit < MIN_PRIMITIVE_CACHE_LIMIT) {
    return MIN_PRIMITIVE_CACHE_LIMIT;
  }

  return normalizedLimit;
};

export const createRunContextEntryCache = <TPayload, TEntry>({
  createEntry,
  limit,
}: CreateRunContextEntryCacheInput<TPayload, TEntry>): RunContextEntryCache<TPayload, TEntry> => {
  const primitiveCacheLimit = resolvePrimitiveCacheLimit(limit);
  const primitiveEntries = new Map<unknown, TEntry>();
  const primitiveOrder = new Set<unknown>();
  let latestObjectEntry: ObjectRunContextEntry<object, TEntry> | null = null;
  let previousObjectEntry: ObjectRunContextEntry<object, TEntry> | null = null;

  const getOrCreate = (payload: TPayload): TEntry => {
    if (payload !== null && typeof payload === 'object') {
      if (latestObjectEntry && Object.is(latestObjectEntry.payload, payload)) {
        return latestObjectEntry.entry;
      }

      if (previousObjectEntry && Object.is(previousObjectEntry.payload, payload)) {
        const promotedObjectEntry = previousObjectEntry;
        previousObjectEntry = latestObjectEntry;
        latestObjectEntry = promotedObjectEntry;
        return promotedObjectEntry.entry;
      }

      const createdEntry = createEntry(payload);
      previousObjectEntry = latestObjectEntry;
      latestObjectEntry = {
        payload,
        entry: createdEntry,
      };
      return createdEntry;
    }

    if (primitiveEntries.has(payload)) {
      const existingPrimitiveEntry = primitiveEntries.get(payload) as TEntry;
      primitiveOrder.delete(payload);
      primitiveOrder.add(payload);
      return existingPrimitiveEntry;
    }

    const createdPrimitiveEntry = createEntry(payload);
    primitiveEntries.set(payload, createdPrimitiveEntry);
    primitiveOrder.add(payload);

    if (primitiveEntries.size > primitiveCacheLimit) {
      const oldestPrimitivePayload = primitiveOrder.values().next().value;
      if (oldestPrimitivePayload !== undefined) {
        primitiveOrder.delete(oldestPrimitivePayload);
        primitiveEntries.delete(oldestPrimitivePayload);
      }
    }

    return createdPrimitiveEntry;
  };

  const clear = (): void => {
    primitiveEntries.clear();
    primitiveOrder.clear();
    latestObjectEntry = null;
    previousObjectEntry = null;
  };

  return {
    getOrCreate,
    clear,
  };
};

1	export interface CreateRunContextEntryCacheInput<TPayload, TEntry> {
2	createEntry: (payload: TPayload) => TEntry;
3	limit: number;
4	}
5
6	export interface RunContextEntryCache<TPayload, TEntry> {
7	getOrCreate: (payload: TPayload) => TEntry;
8	clear: () => void;
9	}
10
11	interface ObjectRunContextEntry<TPayload extends object, TEntry> {
12	payload: TPayload;
13	entry: TEntry;
14	}
15
16	const MIN_PRIMITIVE_CACHE_LIMIT = 1;	19✔
17
18	const resolvePrimitiveCacheLimit = (limit: number): number => {	19✔
19	if (!Number.isFinite(limit)) {	52✔
20	return MIN_PRIMITIVE_CACHE_LIMIT;	×
21	}
22
23	const normalizedLimit = Math.floor(limit);	52✔
24	if (normalizedLimit < MIN_PRIMITIVE_CACHE_LIMIT) {	52✔
25	return MIN_PRIMITIVE_CACHE_LIMIT;	×
26	}
27
28	return normalizedLimit;	52✔
29	};
30
31	export const createRunContextEntryCache = <TPayload, TEntry>({	19✔
32	createEntry,
33	limit,
34	}: CreateRunContextEntryCacheInput<TPayload, TEntry>): RunContextEntryCache<TPayload, TEntry> => {
35	const primitiveCacheLimit = resolvePrimitiveCacheLimit(limit);	52✔
36	const primitiveEntries = new Map<unknown, TEntry>();	52✔
37	const primitiveOrder = new Set<unknown>();	52✔
38	let latestObjectEntry: ObjectRunContextEntry<object, TEntry> \| null = null;	52✔
39	let previousObjectEntry: ObjectRunContextEntry<object, TEntry> \| null = null;	52✔
40
41	const getOrCreate = (payload: TPayload): TEntry => {	52✔
42	if (payload !== null && typeof payload === 'object') {	58✔
43	if (latestObjectEntry && Object.is(latestObjectEntry.payload, payload)) {	24✔
44	return latestObjectEntry.entry;	3✔
45	}
46
47	if (previousObjectEntry && Object.is(previousObjectEntry.payload, payload)) {	21✔
48	const promotedObjectEntry = previousObjectEntry;	×
49	previousObjectEntry = latestObjectEntry;	×
50	latestObjectEntry = promotedObjectEntry;	×
51	return promotedObjectEntry.entry;	×
52	}
53
54	const createdEntry = createEntry(payload);	21✔
55	previousObjectEntry = latestObjectEntry;	21✔
56	latestObjectEntry = {	21✔
57	payload,
58	entry: createdEntry,
59	};
60	return createdEntry;	21✔
61	}
62
63	if (primitiveEntries.has(payload)) {	34✔
64	const existingPrimitiveEntry = primitiveEntries.get(payload) as TEntry;	2✔
65	primitiveOrder.delete(payload);	2✔
66	primitiveOrder.add(payload);	2✔
67	return existingPrimitiveEntry;	2✔
68	}
69
70	const createdPrimitiveEntry = createEntry(payload);	32✔
71	primitiveEntries.set(payload, createdPrimitiveEntry);	32✔
72	primitiveOrder.add(payload);	32✔
73
74	if (primitiveEntries.size > primitiveCacheLimit) {	32✔
75	const oldestPrimitivePayload = primitiveOrder.values().next().value;	×
76	if (oldestPrimitivePayload !== undefined) {	×
77	primitiveOrder.delete(oldestPrimitivePayload);	×
78	primitiveEntries.delete(oldestPrimitivePayload);	×
79	}
80	}
81
82	return createdPrimitiveEntry;	32✔
83	};
84
85	const clear = (): void => {	52✔
86	primitiveEntries.clear();	×
87	primitiveOrder.clear();	×
88	latestObjectEntry = null;	×
89	previousObjectEntry = null;	×
90	};
91
92	return {	52✔
93	getOrCreate,
94	clear,
95	};
96	};

live-input-vector-output-node / livon-ts / 23789194950

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous