@depup/payload 3.79.1-depup.0

package/dist/config/orderable/fractional-indexing.js

@@ -0,0 +1,363 @@
+// @ts-no-check
+/**
+ * THIS FILE IS BASED ON:
+ * https://github.com/rocicorp/fractional-indexing/blob/main/src/index.js
+ *
+ * MODIFIED FOR PAYLOAD CMS:
+ * - Changed the integer part encoding to use only digits for "small" keys and
+ *   only lowercase letters for "large" keys, ensuring consistent ordering
+ *   across databases with different collations.
+ *
+ * - Original algorithm used A-Z (uppercase) for "smaller" integers and a-z (lowercase)
+ *   for "larger" integers, relying on ASCII ordering where 'Z' < 'a'.
+ *
+ * - Some databases (e.g., PostgreSQL with default collation) use case-insensitive
+ *   comparison, treating 'Z' as 'z', which breaks the ordering.
+ *
+ * - New encoding:
+ *   - Uses digits '0'-'9' for "small" integers (10 values, lengths 11 down to 2)
+ *   - Uses lowercase 'a'-'z' for "large" integers (26 values, lengths 2 up to 27)
+ *   - Digits ALWAYS sort before letters in both ASCII and case-insensitive orderings.
+ *
+ * - Ordering: '0...' < '1...' < ... < '9..' < 'a.' < 'b..' < ... < 'z...'
+ *
+ * BACKWARD COMPATIBILITY:
+ * - Existing keys starting with lowercase 'a'-'z' remain valid and work correctly.
+ * - Keys starting with uppercase 'A'-'Z' (from the old algorithm) will still be
+ *   parsed for backward compatibility, but they may sort incorrectly in
+ *   case-insensitive databases. Consider running a migration to convert them.
+ */ // License: CC0 (no rights reserved).
+// This is based on https://observablehq.com/@dgreensp/implementing-fractional-indexing
+export const BASE_36_DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz';
+// `a` may be empty string, `b` is null or non-empty string.
+// `a < b` lexicographically if `b` is non-null.
+// no trailing zeros allowed.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string} a
+ * @param {string | null | undefined} b
+ * @param {string} digits
+ * @returns {string}
+ */ function midpoint(a, b, digits) {
+    const zero = digits[0];
+    if (b != null && a >= b) {
+        throw new Error(a + ' >= ' + b);
+    }
+    if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
+        throw new Error('trailing zero');
+    }
+    if (b) {
+        // remove longest common prefix.  pad `a` with 0s as we
+        // go.  note that we don't need to pad `b`, because it can't
+        // end before `a` while traversing the common prefix.
+        let n = 0;
+        while((a[n] || zero) === b[n]){
+            n++;
+        }
+        if (n > 0) {
+            return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+        }
+    }
+    // first digits (or lack of digit) are different
+    const digitA = a ? digits.indexOf(a[0]) : 0;
+    const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+    if (digitB - digitA > 1) {
+        const midDigit = Math.round(0.5 * (digitA + digitB));
+        return digits[midDigit];
+    } else {
+        // first digits are consecutive
+        if (b && b.length > 1) {
+            return b.slice(0, 1);
+        } else {
+            // `b` is null or has length 1 (a single digit).
+            // the first digit of `a` is the previous digit to `b`,
+            // or 9 if `b` is null.
+            // given, for example, midpoint('49', '5'), return
+            // '4' + midpoint('9', null), which will become
+            // '4' + '9' + midpoint('', null), which is '495'
+            return digits[digitA] + midpoint(a.slice(1), null, digits);
+        }
+    }
+}
+/**
+ * @param {string} int
+ * @return {void}
+ */ function validateInteger(int) {
+    if (int.length !== getIntegerLength(int[0])) {
+        throw new Error('invalid integer part of order key: ' + int);
+    }
+}
+/**
+ * Returns the length of the integer part based on the head character.
+ *
+ * New encoding (case-insensitive safe):
+ * - SMALL range (digits): '0' = 11 chars, '1' = 10 chars, ..., '9' = 2 chars
+ * - LARGE range (lowercase): 'a' = 2 chars, 'b' = 3 chars, ..., 'z' = 27 chars
+ *
+ * Legacy encoding (for backward compatibility with existing keys):
+ * - 'A'-'Z' uppercase: 'A' = 27 chars, 'B' = 26 chars, ..., 'Z' = 2 chars
+ *
+ * @param {string} head
+ * @return {number}
+ */ function getIntegerLength(head) {
+    if (head >= '0' && head <= '9') {
+        return 11 - (head.charCodeAt(0) - '0'.charCodeAt(0));
+    } else if (head >= 'a' && head <= 'z') {
+        return head.charCodeAt(0) - 'a'.charCodeAt(0) + 2;
+    } else if (head >= 'A' && head <= 'Z') {
+        // Legacy encoding
+        return 'Z'.charCodeAt(0) - head.charCodeAt(0) + 2;
+    } else {
+        throw new Error('invalid order key head: ' + head);
+    }
+}
+/**
+ * @param {string} key
+ * @return {string}
+ */ function getIntegerPart(key) {
+    const integerPartLength = getIntegerLength(key[0]);
+    if (integerPartLength > key.length) {
+        throw new Error('invalid order key: ' + key);
+    }
+    return key.slice(0, integerPartLength);
+}
+/**
+ * Smallest possible key (for validation)
+ * '0' + 10 zeros = smallest valid key in new format
+ */ const SMALLEST_KEY = '0' + BASE_36_DIGITS[0].repeat(10);
+/**
+ * @param {string} key
+ * @param {string} digits
+ * @return {void}
+ */ function validateOrderKey(key, digits) {
+    if (key === SMALLEST_KEY) {
+        throw new Error('invalid order key: ' + key);
+    }
+    // Legacy check for old format
+    if (key === 'A' + digits[0].repeat(26)) {
+        throw new Error('invalid order key: ' + key);
+    }
+    // getIntegerPart will throw if the first character is bad,
+    // or the key is too short.  we'd call it to check these things
+    // even if we didn't need the result
+    const i = getIntegerPart(key);
+    const f = key.slice(i.length);
+    if (f.slice(-1) === digits[0]) {
+        throw new Error('invalid order key: ' + key);
+    }
+}
+// note that this may return null, as there is a largest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */ function incrementInteger(x, digits) {
+    validateInteger(x);
+    const [head, ...digs] = x.split('');
+    let carry = true;
+    for(let i = digs.length - 1; carry && i >= 0; i--){
+        const d = digits.indexOf(digs[i]) + 1;
+        if (d === digits.length) {
+            digs[i] = digits[0];
+        } else {
+            digs[i] = digits[d];
+            carry = false;
+        }
+    }
+    if (carry) {
+        if (head === '9') {
+            return 'a' + digits[0];
+        }
+        // Handle legacy uppercase transition
+        if (head === 'Z') {
+            return 'a' + digits[0];
+        }
+        if (head === 'z') {
+            return null;
+        }
+        let h;
+        if (head >= '0' && head <= '8') {
+            h = String.fromCharCode(head.charCodeAt(0) + 1);
+            digs.pop();
+        } else if (head >= 'a' && head <= 'y') {
+            h = String.fromCharCode(head.charCodeAt(0) + 1);
+            digs.push(digits[0]);
+        } else if (head >= 'A' && head <= 'Y') {
+            // Legacy uppercase
+            h = String.fromCharCode(head.charCodeAt(0) + 1);
+            digs.pop();
+        } else {
+            throw new Error('invalid head: ' + head);
+        }
+        return h + digs.join('');
+    } else {
+        return head + digs.join('');
+    }
+}
+// note that this may return null, as there is a smallest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */ function decrementInteger(x, digits) {
+    validateInteger(x);
+    const [head, ...digs] = x.split('');
+    let borrow = true;
+    for(let i = digs.length - 1; borrow && i >= 0; i--){
+        const d = digits.indexOf(digs[i]) - 1;
+        if (d === -1) {
+            digs[i] = digits.slice(-1);
+        } else {
+            digs[i] = digits[d];
+            borrow = false;
+        }
+    }
+    if (borrow) {
+        if (head === 'a') {
+            return '9' + digits.slice(-1);
+        }
+        if (head === '0') {
+            return null;
+        }
+        let h;
+        if (head >= '1' && head <= '9') {
+            h = String.fromCharCode(head.charCodeAt(0) - 1);
+            digs.push(digits.slice(-1));
+        } else if (head >= 'b' && head <= 'z') {
+            h = String.fromCharCode(head.charCodeAt(0) - 1);
+            digs.pop();
+        } else if (head >= 'B' && head <= 'Z') {
+            // Legacy uppercase
+            h = String.fromCharCode(head.charCodeAt(0) - 1);
+            digs.push(digits.slice(-1));
+        } else if (head === 'A') {
+            // Legacy uppercase
+            return null;
+        } else {
+            throw new Error('invalid head: ' + head);
+        }
+        return h + digs.join('');
+    } else {
+        return head + digs.join('');
+    }
+}
+// `a` is an order key or null (START).
+// `b` is an order key or null (END).
+// `a < b` lexicographically if both are non-null.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */ export function generateKeyBetween(a, b, digits = BASE_36_DIGITS) {
+    if (a != null) {
+        validateOrderKey(a, digits);
+    }
+    if (b != null) {
+        validateOrderKey(b, digits);
+    }
+    if (a != null && b != null && a >= b) {
+        throw new Error(a + ' >= ' + b);
+    }
+    if (a == null) {
+        if (b == null) {
+            return 'a' + digits[0];
+        }
+        const ib = getIntegerPart(b);
+        const fb = b.slice(ib.length);
+        if (ib === SMALLEST_KEY) {
+            return ib + midpoint('', fb, digits);
+        }
+        // Legacy check
+        if (ib === 'A' + digits[0].repeat(26)) {
+            return ib + midpoint('', fb, digits);
+        }
+        if (ib < b) {
+            return ib;
+        }
+        const res = decrementInteger(ib, digits);
+        if (res == null) {
+            throw new Error('cannot decrement any more');
+        }
+        return res;
+    }
+    if (b == null) {
+        const ia = getIntegerPart(a);
+        const fa = a.slice(ia.length);
+        const i = incrementInteger(ia, digits);
+        return i == null ? ia + midpoint(fa, null, digits) : i;
+    }
+    const ia = getIntegerPart(a);
+    const fa = a.slice(ia.length);
+    const ib = getIntegerPart(b);
+    const fb = b.slice(ib.length);
+    if (ia === ib) {
+        return ia + midpoint(fa, fb, digits);
+    }
+    const i = incrementInteger(ia, digits);
+    if (i == null) {
+        throw new Error('cannot increment any more');
+    }
+    if (i < b) {
+        return i;
+    }
+    return ia + midpoint(fa, null, digits);
+}
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */ export function generateNKeysBetween(a, b, n, digits = BASE_36_DIGITS) {
+    if (n === 0) {
+        return [];
+    }
+    if (n === 1) {
+        return [
+            generateKeyBetween(a, b, digits)
+        ];
+    }
+    if (b == null) {
+        let c = generateKeyBetween(a, b, digits);
+        const result = [
+            c
+        ];
+        for(let i = 0; i < n - 1; i++){
+            c = generateKeyBetween(c, b, digits);
+            result.push(c);
+        }
+        return result;
+    }
+    if (a == null) {
+        let c = generateKeyBetween(a, b, digits);
+        const result = [
+            c
+        ];
+        for(let i = 0; i < n - 1; i++){
+            c = generateKeyBetween(a, c, digits);
+            result.push(c);
+        }
+        result.reverse();
+        return result;
+    }
+    const mid = Math.floor(n / 2);
+    const c = generateKeyBetween(a, b, digits);
+    return [
+        ...generateNKeysBetween(a, c, mid, digits),
+        c,
+        ...generateNKeysBetween(c, b, n - mid - 1, digits)
+    ];
+}
+
+//# sourceMappingURL=fractional-indexing.js.map

package/dist/config/orderable/fractional-indexing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/orderable/fractional-indexing.js"],"sourcesContent":["// @ts-no-check\n\n/**\n * THIS FILE IS BASED ON:\n * https://github.com/rocicorp/fractional-indexing/blob/main/src/index.js\n *\n * MODIFIED FOR PAYLOAD CMS:\n * - Changed the integer part encoding to use only digits for \"small\" keys and\n *   only lowercase letters for \"large\" keys, ensuring consistent ordering\n *   across databases with different collations.\n *\n * - Original algorithm used A-Z (uppercase) for \"smaller\" integers and a-z (lowercase)\n *   for \"larger\" integers, relying on ASCII ordering where 'Z' < 'a'.\n *\n * - Some databases (e.g., PostgreSQL with default collation) use case-insensitive\n *   comparison, treating 'Z' as 'z', which breaks the ordering.\n *\n * - New encoding:\n *   - Uses digits '0'-'9' for \"small\" integers (10 values, lengths 11 down to 2)\n *   - Uses lowercase 'a'-'z' for \"large\" integers (26 values, lengths 2 up to 27)\n *   - Digits ALWAYS sort before letters in both ASCII and case-insensitive orderings.\n *\n * - Ordering: '0...' < '1...' < ... < '9..' < 'a.' < 'b..' < ... < 'z...'\n *\n * BACKWARD COMPATIBILITY:\n * - Existing keys starting with lowercase 'a'-'z' remain valid and work correctly.\n * - Keys starting with uppercase 'A'-'Z' (from the old algorithm) will still be\n *   parsed for backward compatibility, but they may sort incorrectly in\n *   case-insensitive databases. Consider running a migration to convert them.\n */\n\n// License: CC0 (no rights reserved).\n\n// This is based on https://observablehq.com/@dgreensp/implementing-fractional-indexing\n\nexport const BASE_36_DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz'\n\n// `a` may be empty string, `b` is null or non-empty string.\n// `a < b` lexicographically if `b` is non-null.\n// no trailing zeros allowed.\n// digits is a string such as '0123456789' for base 10.  Digits must be in\n// ascending character code order!\n/**\n * @param {string} a\n * @param {string | null | undefined} b\n * @param {string} digits\n * @returns {string}\n */\nfunction midpoint(a, b, digits) {\n  const zero = digits[0]\n  if (b != null && a >= b) {\n    throw new Error(a + ' >= ' + b)\n  }\n  if (a.slice(-1) === zero || (b && b.slice(-1) === zero)) {\n    throw new Error('trailing zero')\n  }\n  if (b) {\n    // remove longest common prefix.  pad `a` with 0s as we\n    // go.  note that we don't need to pad `b`, because it can't\n    // end before `a` while traversing the common prefix.\n    let n = 0\n    while ((a[n] || zero) === b[n]) {\n      n++\n    }\n    if (n > 0) {\n      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits)\n    }\n  }\n  // first digits (or lack of digit) are different\n  const digitA = a ? digits.indexOf(a[0]) : 0\n  const digitB = b != null ? digits.indexOf(b[0]) : digits.length\n  if (digitB - digitA > 1) {\n    const midDigit = Math.round(0.5 * (digitA + digitB))\n    return digits[midDigit]\n  } else {\n    // first digits are consecutive\n    if (b && b.length > 1) {\n      return b.slice(0, 1)\n    } else {\n      // `b` is null or has length 1 (a single digit).\n      // the first digit of `a` is the previous digit to `b`,\n      // or 9 if `b` is null.\n      // given, for example, midpoint('49', '5'), return\n      // '4' + midpoint('9', null), which will become\n      // '4' + '9' + midpoint('', null), which is '495'\n      return digits[digitA] + midpoint(a.slice(1), null, digits)\n    }\n  }\n}\n\n/**\n * @param {string} int\n * @return {void}\n */\n\nfunction validateInteger(int) {\n  if (int.length !== getIntegerLength(int[0])) {\n    throw new Error('invalid integer part of order key: ' + int)\n  }\n}\n\n/**\n * Returns the length of the integer part based on the head character.\n *\n * New encoding (case-insensitive safe):\n * - SMALL range (digits): '0' = 11 chars, '1' = 10 chars, ..., '9' = 2 chars\n * - LARGE range (lowercase): 'a' = 2 chars, 'b' = 3 chars, ..., 'z' = 27 chars\n *\n * Legacy encoding (for backward compatibility with existing keys):\n * - 'A'-'Z' uppercase: 'A' = 27 chars, 'B' = 26 chars, ..., 'Z' = 2 chars\n *\n * @param {string} head\n * @return {number}\n */\nfunction getIntegerLength(head) {\n  if (head >= '0' && head <= '9') {\n    return 11 - (head.charCodeAt(0) - '0'.charCodeAt(0))\n  } else if (head >= 'a' && head <= 'z') {\n    return head.charCodeAt(0) - 'a'.charCodeAt(0) + 2\n  } else if (head >= 'A' && head <= 'Z') {\n    // Legacy encoding\n    return 'Z'.charCodeAt(0) - head.charCodeAt(0) + 2\n  } else {\n    throw new Error('invalid order key head: ' + head)\n  }\n}\n\n/**\n * @param {string} key\n * @return {string}\n */\n\nfunction getIntegerPart(key) {\n  const integerPartLength = getIntegerLength(key[0])\n  if (integerPartLength > key.length) {\n    throw new Error('invalid order key: ' + key)\n  }\n  return key.slice(0, integerPartLength)\n}\n\n/**\n * Smallest possible key (for validation)\n * '0' + 10 zeros = smallest valid key in new format\n */\nconst SMALLEST_KEY = '0' + BASE_36_DIGITS[0].repeat(10)\n\n/**\n * @param {string} key\n * @param {string} digits\n * @return {void}\n */\n\nfunction validateOrderKey(key, digits) {\n  if (key === SMALLEST_KEY) {\n    throw new Error('invalid order key: ' + key)\n  }\n  // Legacy check for old format\n  if (key === 'A' + digits[0].repeat(26)) {\n    throw new Error('invalid order key: ' + key)\n  }\n  // getIntegerPart will throw if the first character is bad,\n  // or the key is too short.  we'd call it to check these things\n  // even if we didn't need the result\n  const i = getIntegerPart(key)\n  const f = key.slice(i.length)\n  if (f.slice(-1) === digits[0]) {\n    throw new Error('invalid order key: ' + key)\n  }\n}\n\n// note that this may return null, as there is a largest integer\n/**\n * @param {string} x\n * @param {string} digits\n * @return {string | null}\n */\nfunction incrementInteger(x, digits) {\n  validateInteger(x)\n  const [head, ...digs] = x.split('')\n  let carry = true\n  for (let i = digs.length - 1; carry && i >= 0; i--) {\n    const d = digits.indexOf(digs[i]) + 1\n    if (d === digits.length) {\n      digs[i] = digits[0]\n    } else {\n      digs[i] = digits[d]\n      carry = false\n    }\n  }\n  if (carry) {\n    if (head === '9') {\n      return 'a' + digits[0]\n    }\n    // Handle legacy uppercase transition\n    if (head === 'Z') {\n      return 'a' + digits[0]\n    }\n    if (head === 'z') {\n      return null\n    }\n\n    let h\n    if (head >= '0' && head <= '8') {\n      h = String.fromCharCode(head.charCodeAt(0) + 1)\n      digs.pop()\n    } else if (head >= 'a' && head <= 'y') {\n      h = String.fromCharCode(head.charCodeAt(0) + 1)\n      digs.push(digits[0])\n    } else if (head >= 'A' && head <= 'Y') {\n      // Legacy uppercase\n      h = String.fromCharCode(head.charCodeAt(0) + 1)\n      digs.pop()\n    } else {\n      throw new Error('invalid head: ' + head)\n    }\n    return h + digs.join('')\n  } else {\n    return head + digs.join('')\n  }\n}\n\n// note that this may return null, as there is a smallest integer\n/**\n * @param {string} x\n * @param {string} digits\n * @return {string | null}\n */\n\nfunction decrementInteger(x, digits) {\n  validateInteger(x)\n  const [head, ...digs] = x.split('')\n  let borrow = true\n  for (let i = digs.length - 1; borrow && i >= 0; i--) {\n    const d = digits.indexOf(digs[i]) - 1\n    if (d === -1) {\n      digs[i] = digits.slice(-1)\n    } else {\n      digs[i] = digits[d]\n      borrow = false\n    }\n  }\n  if (borrow) {\n    if (head === 'a') {\n      return '9' + digits.slice(-1)\n    }\n    if (head === '0') {\n      return null\n    }\n\n    let h\n    if (head >= '1' && head <= '9') {\n      h = String.fromCharCode(head.charCodeAt(0) - 1)\n      digs.push(digits.slice(-1))\n    } else if (head >= 'b' && head <= 'z') {\n      h = String.fromCharCode(head.charCodeAt(0) - 1)\n      digs.pop()\n    } else if (head >= 'B' && head <= 'Z') {\n      // Legacy uppercase\n      h = String.fromCharCode(head.charCodeAt(0) - 1)\n      digs.push(digits.slice(-1))\n    } else if (head === 'A') {\n      // Legacy uppercase\n      return null\n    } else {\n      throw new Error('invalid head: ' + head)\n    }\n    return h + digs.join('')\n  } else {\n    return head + digs.join('')\n  }\n}\n\n// `a` is an order key or null (START).\n// `b` is an order key or null (END).\n// `a < b` lexicographically if both are non-null.\n// digits is a string such as '0123456789' for base 10.  Digits must be in\n// ascending character code order!\n/**\n * @param {string | null | undefined} a\n * @param {string | null | undefined} b\n * @param {string=} digits\n * @return {string}\n */\nexport function generateKeyBetween(a, b, digits = BASE_36_DIGITS) {\n  if (a != null) {\n    validateOrderKey(a, digits)\n  }\n  if (b != null) {\n    validateOrderKey(b, digits)\n  }\n  if (a != null && b != null && a >= b) {\n    throw new Error(a + ' >= ' + b)\n  }\n  if (a == null) {\n    if (b == null) {\n      return 'a' + digits[0]\n    }\n\n    const ib = getIntegerPart(b)\n    const fb = b.slice(ib.length)\n    if (ib === SMALLEST_KEY) {\n      return ib + midpoint('', fb, digits)\n    }\n    // Legacy check\n    if (ib === 'A' + digits[0].repeat(26)) {\n      return ib + midpoint('', fb, digits)\n    }\n    if (ib < b) {\n      return ib\n    }\n    const res = decrementInteger(ib, digits)\n    if (res == null) {\n      throw new Error('cannot decrement any more')\n    }\n    return res\n  }\n\n  if (b == null) {\n    const ia = getIntegerPart(a)\n    const fa = a.slice(ia.length)\n    const i = incrementInteger(ia, digits)\n    return i == null ? ia + midpoint(fa, null, digits) : i\n  }\n\n  const ia = getIntegerPart(a)\n  const fa = a.slice(ia.length)\n  const ib = getIntegerPart(b)\n  const fb = b.slice(ib.length)\n  if (ia === ib) {\n    return ia + midpoint(fa, fb, digits)\n  }\n  const i = incrementInteger(ia, digits)\n  if (i == null) {\n    throw new Error('cannot increment any more')\n  }\n  if (i < b) {\n    return i\n  }\n  return ia + midpoint(fa, null, digits)\n}\n\n/**\n * same preconditions as generateKeysBetween.\n * n >= 0.\n * Returns an array of n distinct keys in sorted order.\n * If a and b are both null, returns [a0, a1, ...]\n * If one or the other is null, returns consecutive \"integer\"\n * keys.  Otherwise, returns relatively short keys between\n * a and b.\n * @param {string | null | undefined} a\n * @param {string | null | undefined} b\n * @param {number} n\n * @param {string} digits\n * @return {string[]}\n */\nexport function generateNKeysBetween(a, b, n, digits = BASE_36_DIGITS) {\n  if (n === 0) {\n    return []\n  }\n  if (n === 1) {\n    return [generateKeyBetween(a, b, digits)]\n  }\n  if (b == null) {\n    let c = generateKeyBetween(a, b, digits)\n    const result = [c]\n    for (let i = 0; i < n - 1; i++) {\n      c = generateKeyBetween(c, b, digits)\n      result.push(c)\n    }\n    return result\n  }\n  if (a == null) {\n    let c = generateKeyBetween(a, b, digits)\n    const result = [c]\n    for (let i = 0; i < n - 1; i++) {\n      c = generateKeyBetween(a, c, digits)\n      result.push(c)\n    }\n    result.reverse()\n    return result\n  }\n  const mid = Math.floor(n / 2)\n  const c = generateKeyBetween(a, b, digits)\n  return [\n    ...generateNKeysBetween(a, c, mid, digits),\n    c,\n    ...generateNKeysBetween(c, b, n - mid - 1, digits),\n  ]\n}\n"],"names":["BASE_36_DIGITS","midpoint","a","b","digits","zero","Error","slice","n","digitA","indexOf","digitB","length","midDigit","Math","round","validateInteger","int","getIntegerLength","head","charCodeAt","getIntegerPart","key","integerPartLength","SMALLEST_KEY","repeat","validateOrderKey","i","f","incrementInteger","x","digs","split","carry","d","h","String","fromCharCode","pop","push","join","decrementInteger","borrow","generateKeyBetween","ib","fb","res","ia","fa","generateNKeysBetween","c","result","reverse","mid","floor"],"mappings":"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"}

package/dist/config/orderable/index.d.ts

@@ -0,0 +1,28 @@
+import type { CollectionConfig } from '../../collections/config/types.js';
+import type { SanitizedConfig } from '../types.js';
+/**
+ * This function creates:
+ * - N fields per collection, named `_order` or `_<collection>_<joinField>_order`
+ * - 1 hook per collection
+ * - 1 endpoint per app
+ *
+ * Also, if collection.defaultSort or joinField.defaultSort is not set, it will be set to the orderable field.
+ */
+export declare const setupOrderable: (config: SanitizedConfig) => void;
+export declare const addOrderableFieldsAndHook: (collection: CollectionConfig, orderableFieldNames: string[], joinFieldPathsByCollection?: Map<string, Map<string, string>>) => void;
+/**
+ * The body of the reorder endpoint.
+ * @internal
+ */
+export type OrderableEndpointBody = {
+    collectionSlug: string;
+    docsToMove: string[];
+    newKeyWillBe: 'greater' | 'less';
+    orderableFieldName: string;
+    target: {
+        id: string;
+        key: string;
+    };
+};
+export declare const addOrderableEndpoint: (config: SanitizedConfig, joinFieldPathsByCollection: Map<string, Map<string, string>>) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/orderable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/orderable/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAE3F,OAAO,KAAK,EAA4B,eAAe,EAAE,MAAM,aAAa,CAAA;AAc5E;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,WAAY,eAAe,SA2DrD,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,gBAAgB,uBACP,MAAM,EAAE,+BACA,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,SA2E9D,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,YAAY,EAAE,SAAS,GAAG,MAAM,CAAA;IAChC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,MAAM,EAAE;QACN,EAAE,EAAE,MAAM,CAAA;QACV,GAAG,EAAE,MAAM,CAAA;KACZ,CAAA;CACF,CAAA;AAED,eAAO,MAAM,oBAAoB,WACvB,eAAe,8BACK,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,SA4L7D,CAAA"}