ts-server-lib 0.0.48

package/utils/object-keys.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Allocation-free own-key predicates — the counting half of the cooperative-yield rules (CLY-3).
+ *
+ * ### The defect these replace
+ *
+ * `Object.keys(o).length > 0` and `Object.keys(o).length === 0` both MATERIALISE an array of every key to
+ * answer a question the first key already settles. On a per-message path that is a throwaway allocation per
+ * call, sized by the object — and the objects on a feed path are markets and outcomes, so they are not
+ * small. `Object.values(o).length` and `Object.entries(o).length` are worse: they build the values or the
+ * pairs as well.
+ *
+ * Both functions here return on the first iteration for the populated case and iterate nothing for the empty
+ * one, so neither ever allocates.
+ *
+ * ### Why they live in ts-server-lib
+ *
+ * Same reason `TSFifo` does. The canonical copies were in core-service, one layer too high for the two
+ * packages that most need them: this library's own hot paths, and the atfeed betradar driver — whose
+ * `Object.keys(...).length` calls run INSIDE the AMQP parse worker, once per market on every odds message.
+ * Neither can import core-service, so without these they would each grow their own copy.
+ *
+ * NOTE: core-service still carries its own `hasOwnKey`/`countOwnKeys` in
+ * `common/resilience/cooperative-yield.ts`. Collapsing that onto these is the right end state, but it
+ * couples core-service to a ts-server-lib version and is deliberately left as a separate, coordinated
+ * change rather than folded into a publish.
+ */
+/**
+ * True when `o` has at least one own enumerable key.
+ *
+ * Prefer over `countOwnKeys(o) > 0`: counting walks every entry to answer a question the first key settles.
+ */
+export declare function hasOwnKey(o: object): boolean;
+/**
+ * Number of own enumerable keys, counted by enumeration rather than by building an array.
+ *
+ * Use only when the COUNT itself is needed. When the question is merely "is it empty", {@link hasOwnKey}
+ * answers it without walking the whole object.
+ */
+export declare function countOwnKeys(o: object): number;

package/utils/object-keys.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Allocation-free own-key predicates — the counting half of the cooperative-yield rules (CLY-3).
+ *
+ * ### The defect these replace
+ *
+ * `Object.keys(o).length > 0` and `Object.keys(o).length === 0` both MATERIALISE an array of every key to
+ * answer a question the first key already settles. On a per-message path that is a throwaway allocation per
+ * call, sized by the object — and the objects on a feed path are markets and outcomes, so they are not
+ * small. `Object.values(o).length` and `Object.entries(o).length` are worse: they build the values or the
+ * pairs as well.
+ *
+ * Both functions here return on the first iteration for the populated case and iterate nothing for the empty
+ * one, so neither ever allocates.
+ *
+ * ### Why they live in ts-server-lib
+ *
+ * Same reason `TSFifo` does. The canonical copies were in core-service, one layer too high for the two
+ * packages that most need them: this library's own hot paths, and the atfeed betradar driver — whose
+ * `Object.keys(...).length` calls run INSIDE the AMQP parse worker, once per market on every odds message.
+ * Neither can import core-service, so without these they would each grow their own copy.
+ *
+ * NOTE: core-service still carries its own `hasOwnKey`/`countOwnKeys` in
+ * `common/resilience/cooperative-yield.ts`. Collapsing that onto these is the right end state, but it
+ * couples core-service to a ts-server-lib version and is deliberately left as a separate, coordinated
+ * change rather than folded into a publish.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOwnKey = hasOwnKey;
+exports.countOwnKeys = countOwnKeys;
+/**
+ * True when `o` has at least one own enumerable key.
+ *
+ * Prefer over `countOwnKeys(o) > 0`: counting walks every entry to answer a question the first key settles.
+ */
+function hasOwnKey(o) {
+    for (const _ in o)
+        return true;
+    return false;
+}
+/**
+ * Number of own enumerable keys, counted by enumeration rather than by building an array.
+ *
+ * Use only when the COUNT itself is needed. When the question is merely "is it empty", {@link hasOwnKey}
+ * answers it without walking the whole object.
+ */
+function countOwnKeys(o) {
+    let n = 0;
+    for (const _ in o)
+        n++;
+    return n;
+}