qstd 0.3.84 → 0.3.85

package/dist/shared/lexorank/domain.d.ts

@@ -0,0 +1,71 @@
+import * as _t from "./types";
+/**
+ * Generate a new sort key between two adjacent items.
+ *
+ * Given the order strings of the previous and next items, produces a
+ * string that sorts lexicographically between them. Pass empty strings
+ * for boundaries (insert at start or end).
+ *
+ * Algorithm uses lowercase a-z (char codes 96-123) as the alphabet:
+ * - 96 = boundary before 'a'
+ * - 123 = boundary after 'z'
+ *
+ * @example
+ * createOrderStr("b", "d")   // "c"
+ * createOrderStr("", "b")    // "a" (or similar, insert at start)
+ * createOrderStr("n", "")    // "t" (or similar, insert at end)
+ * createOrderStr("az", "b")  // "an" (midpoint between "az" and "b")
+ */
+export declare const createOrderStr: (prev?: string, next?: string) => string;
+/**
+ * Generate evenly-spaced order keys for a list of a given size.
+ *
+ * Used for initial list creation and periodic rebalancing. Produces
+ * `num` strings that are roughly evenly distributed across the a-z
+ * alphabet space, minimizing future string growth.
+ *
+ * @example
+ * createRebalancedOrderList(3)  // ["i", "r", "z"] (roughly evenly spaced)
+ * createRebalancedOrderList(5)  // ["e", "j", "o", "t", "y"]
+ */
+export declare const createRebalancedOrderList: (num: number) => string[];
+/**
+ * Check if the order strings in a list need rebalancing.
+ *
+ * Returns true when the longest order string exceeds half the list size.
+ * This indicates too many consecutive edge insertions have caused string
+ * growth. Rebalancing is rare in normal usage patterns.
+ *
+ * @example
+ * checkBalance([{ order: "b" }, { order: "n" }])       // false (1 < 1)
+ * checkBalance([{ order: "aaaaax" }, { order: "b" }])   // true  (6 > 1)
+ */
+export declare const checkBalance: <T extends _t.Ordered>(xs: T[]) => boolean;
+/**
+ * Rebalance a list by recomputing evenly-spaced order keys for every item.
+ *
+ * Eliminates long order strings caused by repeated edge insertions.
+ * Returns new items with fresh `order` values. Does not mutate input.
+ *
+ * @example
+ * const items = [
+ *   { id: "a", order: "aaaaax" },
+ *   { id: "b", order: "b" },
+ *   { id: "c", order: "n" },
+ * ];
+ * rebalance(items);
+ * // [{ id: "a", order: "i" }, { id: "b", order: "r" }, { id: "c", order: "z" }]
+ */
+export declare const rebalance: <T extends _t.Ordered>(xs: T[]) => (T & {
+    order: string;
+})[];
+/**
+ * Sort items by their lexicographic order strings.
+ *
+ * Returns a new sorted array (immutable). Items without an order
+ * field sort to the beginning.
+ */
+export declare const sortByOrder: <T extends {
+    order?: string;
+}>(xs: T[]) => T[];
+//# sourceMappingURL=domain.d.ts.map

package/dist/shared/lexorank/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/domain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAI9B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAI,aAAS,EAAE,aAAS,WA0ClD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GAAI,KAAK,MAAM,aAiCpD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,YAMzD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;;IAGtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,CAAC,EAAE,QACI,CAAC"}

package/dist/shared/lexorank/fns.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strip trailing 'a' characters from a string.
+ *
+ * During order list generation, intermediate strings can end with runs
+ * of 'a's that add length without information. Stripping them produces
+ * shorter, cleaner keys that still sort correctly.
+ *
+ * @example
+ * stripTrailingAs("naaa") // "n"
+ * stripTrailingAs("abc")  // "abc"
+ * stripTrailingAs("a")    // ""
+ */
+export declare const stripTrailingAs: (str: string) => string;
+/**
+ * Generate a partial alphabet for evenly distributing keys.
+ *
+ * Uses a bit-packed lookup table to select well-distributed
+ * characters from the a-z range based on the desired count.
+ * For counts >= 13, the table mirrors to cover the full range.
+ *
+ * @example
+ * partialAlphabet(3) // ["d", "n", "x"] (roughly evenly spaced)
+ */
+export declare const partialAlphabet: (num: number) => string[];
+//# sourceMappingURL=fns.d.ts.map

package/dist/shared/lexorank/fns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fns.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/fns.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,WAI1C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,aAW1C,CAAC"}

package/dist/shared/lexorank/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LexoRank Ordering
+ *
+ * Lexicographic string-based ordering for collection items.
+ * Enables O(1) reorder operations: moving an item between two others
+ * generates a new order string between their existing orders.
+ *
+ * Key functions:
+ * - `createOrderStr(prev, next)` - Generate key between two adjacent items
+ * - `createRebalancedOrderList(num)` - Generate evenly-spaced keys for a list
+ * - `checkBalance(xs)` - Detect when rebalancing is needed
+ * - `rebalance(xs)` - Recompute all orders
+ * - `sortByOrder(xs)` - Sort items by lexicographic order
+ */
+export type * from "./types";
+export * from "./domain";
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/lexorank/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,mBAAmB,SAAS,CAAC;AAC7B,cAAc,UAAU,CAAC"}

package/dist/shared/lexorank/literals.d.ts

@@ -0,0 +1,20 @@
+/** Char code for the lower bound sentinel (one below 'a') */
+export declare const LOWER_BOUND = 96;
+/** Char code for the upper bound sentinel (one above 'z') */
+export declare const UPPER_BOUND = 123;
+/** Char code for 'a' — first character in the usable alphabet */
+export declare const CHAR_A = 97;
+/** Char code for 'z' — last character in the usable alphabet */
+export declare const CHAR_Z = 122;
+/** Size of the a-z alphabet */
+export declare const ALPHABET_SIZE = 26;
+/**
+ * Bit-packed lookup table for selecting well-distributed characters
+ * from the a-z range when generating evenly-spaced order keys.
+ *
+ * Each entry encodes which of the 25 non-'a' characters to include
+ * when distributing `n` keys across the alphabet. For n >= 13, the
+ * table is mirrored using a 25-bit mask (2^25 - 1 = 33554431).
+ */
+export declare const DISTRIBUTION_TABLE: readonly [0, 4096, 65792, 528416, 1081872, 2167048, 2376776, 4756004, 4794660, 5411476, 9775442, 11097386, 11184810, 22369621];
+//# sourceMappingURL=literals.d.ts.map

package/dist/shared/lexorank/literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/literals.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,6DAA6D;AAC7D,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,iEAAiE;AACjE,eAAO,MAAM,MAAM,KAAK,CAAC;AAEzB,gEAAgE;AAChE,eAAO,MAAM,MAAM,MAAM,CAAC;AAE1B,+BAA+B;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,gIAGrB,CAAC"}

package/dist/shared/lexorank/types.d.ts

@@ -0,0 +1,5 @@
+/** Item with a lexicographic order field */
+export interface Ordered {
+    order: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/lexorank/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/types.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qstd",
-  "version": "0.3.84",
+  "version": "0.3.85",
   "description": "Standard Block component and utilities library with Panda CSS",
   "author": "malin1",
   "license": "MIT",