@visulima/pagination 3.0.24 → 3.0.25

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## @visulima/pagination [3.0.25](https://github.com/visulima/visulima/compare/@visulima/pagination@3.0.24...@visulima/pagination@3.0.25) (2025-01-12)
+
+### Bug Fixes
+
+* updated @visulima/packem, and all other dev dependencies ([7797a1c](https://github.com/visulima/visulima/commit/7797a1c3e6f1fc532895247bd88285a8a9883c40))
+
+### Miscellaneous Chores
+
+* updated dev dependencies ([9de2eab](https://github.com/visulima/visulima/commit/9de2eab91e95c8b9289d12f863a5167218770650))
+
 ## @visulima/pagination [3.0.24](https://github.com/visulima/visulima/compare/@visulima/pagination@3.0.23...@visulima/pagination@3.0.24) (2024-12-12)
 
 ### Bug Fixes

package/dist/index.cjs

@@ -1 +1,15 @@
-"use strict";var o=Object.defineProperty;var t=(e,a)=>o(e,"name",{value:a,configurable:!0});Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./packem_shared/Paginator-dO9FtCU3.cjs"),i=require("./packem_shared/createPaginationMetaSchemaObject-D-0GFE4M.cjs");var g=Object.defineProperty,b=t((e,a)=>g(e,"name",{value:a,configurable:!0}),"e");const m=b((e,a,r,c)=>new n(r,Number(a),Number(e),...c),"paginate");exports.Paginator=n;exports.createPaginationMetaSchemaObject=i.createPaginationMetaSchemaObject;exports.createPaginationSchemaObject=i.createPaginationSchemaObject;exports.paginate=m;
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const Paginator = require('./packem_shared/Paginator-Bzp4q-CL.cjs');
+const createPaginationMetaSchemaObject = require('./packem_shared/createPaginationMetaSchemaObject-B2_MNxET.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const paginate = /* @__PURE__ */ __name((page, perPage, total, rows) => new Paginator(total, Number(perPage), Number(page), ...rows), "paginate");
+
+exports.Paginator = Paginator;
+exports.createPaginationMetaSchemaObject = createPaginationMetaSchemaObject.createPaginationMetaSchemaObject;
+exports.createPaginationSchemaObject = createPaginationMetaSchemaObject.createPaginationSchemaObject;
+exports.paginate = paginate;

package/dist/index.mjs

@@ -1 +1,8 @@
-var o=Object.defineProperty;var t=(e,a)=>o(e,"name",{value:a,configurable:!0});import i from"./packem_shared/Paginator-DI6QB_Ve.mjs";import{createPaginationMetaSchemaObject as P,createPaginationSchemaObject as j}from"./packem_shared/createPaginationMetaSchemaObject-6bBOLPmK.mjs";var c=Object.defineProperty,m=t((e,a)=>c(e,"name",{value:a,configurable:!0}),"e");const p=m((e,a,r,n)=>new i(r,Number(a),Number(e),...n),"paginate");export{i as Paginator,P as createPaginationMetaSchemaObject,j as createPaginationSchemaObject,p as paginate};
+import Paginator from './packem_shared/Paginator-Cn8d66Nq.mjs';
+export { createPaginationMetaSchemaObject, createPaginationSchemaObject } from './packem_shared/createPaginationMetaSchemaObject-fEupXBbv.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const paginate = /* @__PURE__ */ __name((page, perPage, total, rows) => new Paginator(total, Number(perPage), Number(page), ...rows), "paginate");
+
+export { Paginator, paginate };

package/dist/packem_shared/Paginator-Bzp4q-CL.cjs

@@ -0,0 +1,529 @@
+'use strict';
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+const replace = String.prototype.replace;
+const percentTwenties = /%20/g;
+const Format = {
+  RFC1738: "RFC1738",
+  RFC3986: "RFC3986"
+};
+const formatters = {
+  RFC1738: /* @__PURE__ */ __name$3(function(value) {
+    return replace.call(value, percentTwenties, "+");
+  }, "RFC1738"),
+  RFC3986: /* @__PURE__ */ __name$3(function(value) {
+    return String(value);
+  }, "RFC3986")
+};
+const RFC1738 = Format.RFC1738;
+const formats = Format.RFC3986;
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+const isArray$1 = Array.isArray;
+const hexTable = function() {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
+  }
+  return array;
+}();
+const limit = 1024;
+const encode = /* @__PURE__ */ __name$2(function encode2(str, defaultEncoder, charset, kind, format) {
+  if (str.length === 0) {
+    return str;
+  }
+  let string = str;
+  if (typeof str === "symbol") {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== "string") {
+    string = String(str);
+  }
+  if (charset === "iso-8859-1") {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
+      return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+    });
+  }
+  let out = "";
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (c === 45 || // -
+      c === 46 || // .
+      c === 95 || // _
+      c === 126 || // ~
+      c >= 48 && c <= 57 || // 0-9
+      c >= 65 && c <= 90 || // a-z
+      c >= 97 && c <= 122 || // A-Z
+      format === RFC1738 && (c === 40 || c === 41)) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+      if (c < 128) {
+        arr[arr.length] = hexTable[c];
+        continue;
+      }
+      if (c < 2048) {
+        arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
+        continue;
+      }
+      if (c < 55296 || c >= 57344) {
+        arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+        continue;
+      }
+      i += 1;
+      c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
+      arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+    }
+    out += arr.join("");
+  }
+  return out;
+}, "encode");
+const isBuffer = /* @__PURE__ */ __name$2(function isBuffer2(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}, "isBuffer");
+const maybeMap = /* @__PURE__ */ __name$2(function maybeMap2(val, fn) {
+  if (isArray$1(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]));
+    }
+    return mapped;
+  }
+  return fn(val);
+}, "maybeMap");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const has = Object.prototype.hasOwnProperty;
+const arrayPrefixGenerators = {
+  brackets: /* @__PURE__ */ __name$1(function brackets(prefix) {
+    return prefix + "[]";
+  }, "brackets"),
+  comma: "comma",
+  indices: /* @__PURE__ */ __name$1(function indices(prefix, key) {
+    return prefix + "[" + key + "]";
+  }, "indices"),
+  repeat: /* @__PURE__ */ __name$1(function repeat(prefix) {
+    return prefix;
+  }, "repeat")
+};
+const isArray = Array.isArray;
+const push = Array.prototype.push;
+const pushToArray = /* @__PURE__ */ __name$1(function(arr, valueOrArray) {
+  push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+}, "pushToArray");
+const toISO = Date.prototype.toISOString;
+const defaultFormat = formats;
+const defaults = {
+  addQueryPrefix: false,
+  allowDots: false,
+  allowEmptyArrays: false,
+  arrayFormat: "indices",
+  charset: "utf-8",
+  charsetSentinel: false,
+  delimiter: "&",
+  encode: true,
+  encodeDotInKeys: false,
+  encoder: encode,
+  encodeValuesOnly: false,
+  format: defaultFormat,
+  formatter: formatters[defaultFormat],
+  // deprecated
+  indices: false,
+  serializeDate: /* @__PURE__ */ __name$1(function serializeDate(date) {
+    return toISO.call(date);
+  }, "serializeDate"),
+  skipNulls: false,
+  strictNullHandling: false
+};
+const isNonNullishPrimitive = /* @__PURE__ */ __name$1(function isNonNullishPrimitive2(v) {
+  return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+}, "isNonNullishPrimitive");
+const sentinel = {};
+const _stringify = /* @__PURE__ */ __name$1(function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate2, format, formatter, encodeValuesOnly, charset, sideChannel) {
+  let obj = object;
+  let tmpSc = sideChannel;
+  let step = 0;
+  let findFlag = false;
+  while ((tmpSc = tmpSc.get(sentinel)) !== undefined && !findFlag) {
+    const pos = tmpSc.get(object);
+    step += 1;
+    if (typeof pos !== "undefined") {
+      if (pos === step) {
+        throw new RangeError("Cyclic object value");
+      } else {
+        findFlag = true;
+      }
+    }
+    if (typeof tmpSc.get(sentinel) === "undefined") {
+      step = 0;
+    }
+  }
+  if (typeof filter === "function") {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate2(obj);
+  } else if (generateArrayPrefix === "comma" && isArray(obj)) {
+    obj = maybeMap(obj, function(value) {
+      if (value instanceof Date) {
+        return serializeDate2(value);
+      }
+      return value;
+    });
+  }
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix;
+    }
+    obj = "";
+  }
+  if (isNonNullishPrimitive(obj) || isBuffer(obj)) {
+    if (encoder) {
+      const keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format);
+      return [
+        formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format))
+      ];
+    }
+    return [formatter(prefix) + "=" + formatter(String(obj))];
+  }
+  const values = [];
+  if (typeof obj === "undefined") {
+    return values;
+  }
+  let objKeys;
+  if (generateArrayPrefix === "comma" && isArray(obj)) {
+    if (encodeValuesOnly && encoder) {
+      obj = maybeMap(obj, encoder);
+    }
+    objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : undefined }];
+  } else if (isArray(filter)) {
+    objKeys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    objKeys = sort ? keys.sort(sort) : keys;
+  }
+  const encodedPrefix = encodeDotInKeys ? prefix.replace(/\./g, "%2E") : prefix;
+  const adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    return adjustedPrefix + "[]";
+  }
+  for (let j = 0; j < objKeys.length; ++j) {
+    const key = objKeys[j];
+    const value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
+    if (skipNulls && value === null) {
+      continue;
+    }
+    const encodedKey = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key;
+    const keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
+    sideChannel.set(object, step);
+    const valueSideChannel = /* @__PURE__ */ new WeakMap();
+    valueSideChannel.set(sentinel, sideChannel);
+    pushToArray(
+      values,
+      _stringify(
+        value,
+        keyPrefix,
+        generateArrayPrefix,
+        commaRoundTrip,
+        allowEmptyArrays,
+        strictNullHandling,
+        skipNulls,
+        encodeDotInKeys,
+        generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder,
+        filter,
+        sort,
+        allowDots,
+        serializeDate2,
+        format,
+        formatter,
+        encodeValuesOnly,
+        charset,
+        valueSideChannel
+      )
+    );
+  }
+  return values;
+}, "stringify");
+const normalizeStringifyOptions = /* @__PURE__ */ __name$1(function normalizeStringifyOptions2(opts) {
+  if (!opts) {
+    return defaults;
+  }
+  if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+    throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+  }
+  if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
+    throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+  }
+  if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+    throw new TypeError("Encoder has to be a function.");
+  }
+  const charset = opts.charset || defaults.charset;
+  if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+    throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+  }
+  let format = formats;
+  if (typeof opts.format !== "undefined") {
+    if (!has.call(formatters, opts.format)) {
+      throw new TypeError("Unknown format option provided.");
+    }
+    format = opts.format;
+  }
+  const formatter = formatters[format];
+  let filter = defaults.filter;
+  if (typeof opts.filter === "function" || isArray(opts.filter)) {
+    filter = opts.filter;
+  }
+  let arrayFormat;
+  if (opts.arrayFormat in arrayPrefixGenerators) {
+    arrayFormat = opts.arrayFormat;
+  } else if ("indices" in opts) {
+    arrayFormat = opts.indices ? "indices" : "repeat";
+  } else {
+    arrayFormat = defaults.arrayFormat;
+  }
+  if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+    throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+  }
+  const allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    allowDots,
+    allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat,
+    charset,
+    charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: opts.commaRoundTrip,
+    delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+    encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+    encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+    encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+    encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+    filter,
+    format,
+    formatter,
+    serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
+    skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
+    sort: typeof opts.sort === "function" ? opts.sort : null,
+    strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+  };
+}, "normalizeStringifyOptions");
+function stringify(object, opts) {
+  let obj = object;
+  const options = normalizeStringifyOptions(opts);
+  let objKeys;
+  let filter;
+  if (typeof options.filter === "function") {
+    filter = options.filter;
+    obj = filter("", obj);
+  } else if (isArray(options.filter)) {
+    filter = options.filter;
+    objKeys = filter;
+  }
+  const keys = [];
+  if (typeof obj !== "object" || obj === null) {
+    return "";
+  }
+  const generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
+  const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+  if (!objKeys) {
+    objKeys = Object.keys(obj);
+  }
+  if (options.sort) {
+    objKeys.sort(options.sort);
+  }
+  const sideChannel = /* @__PURE__ */ new WeakMap();
+  for (let i = 0; i < objKeys.length; ++i) {
+    const key = objKeys[i];
+    if (options.skipNulls && obj[key] === null) {
+      continue;
+    }
+    pushToArray(
+      keys,
+      _stringify(
+        obj[key],
+        key,
+        generateArrayPrefix,
+        commaRoundTrip,
+        options.allowEmptyArrays,
+        options.strictNullHandling,
+        options.skipNulls,
+        options.encodeDotInKeys,
+        options.encode ? options.encoder : null,
+        options.filter,
+        options.sort,
+        options.allowDots,
+        options.serializeDate,
+        options.format,
+        options.formatter,
+        options.encodeValuesOnly,
+        options.charset,
+        sideChannel
+      )
+    );
+  }
+  const joined = keys.join(options.delimiter);
+  let prefix = options.addQueryPrefix === true ? "?" : "";
+  if (options.charsetSentinel) {
+    if (options.charset === "iso-8859-1") {
+      prefix += "utf8=%26%2310003%3B&";
+    } else {
+      prefix += "utf8=%E2%9C%93&";
+    }
+  }
+  return joined.length > 0 ? prefix + joined : "";
+}
+__name$1(stringify, "stringify");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Paginator extends Array {
+  constructor(totalNumber, perPage, currentPage, ...rows) {
+    super(...rows);
+    this.totalNumber = totalNumber;
+    this.perPage = perPage;
+    this.currentPage = currentPage;
+    this.totalNumber = Number(totalNumber);
+    this.rows = rows;
+    this.isEmpty = this.rows.length === 0;
+  }
+  static {
+    __name(this, "Paginator");
+  }
+  /**
+   * The first page is always 1
+   */
+  firstPage = 1;
+  /**
+   * Find if results set is empty or not
+   */
+  isEmpty;
+  qs = {};
+  rows;
+  url = "/";
+  /**
+   * A reference to the result rows
+   */
+  all() {
+    return this.rows;
+  }
+  /**
+   * Define base url for making the pagination links
+   */
+  baseUrl(url) {
+    this.url = url;
+    return this;
+  }
+  /**
+   * Returns JSON meta data
+   */
+  getMeta() {
+    return {
+      firstPage: this.firstPage,
+      firstPageUrl: this.getUrl(1),
+      lastPage: this.lastPage,
+      lastPageUrl: this.getUrl(this.lastPage),
+      nextPageUrl: this.getNextPageUrl(),
+      page: this.currentPage,
+      perPage: this.perPage,
+      previousPageUrl: this.getPreviousPageUrl(),
+      total: this.total
+    };
+  }
+  /**
+   * Returns url for the next page
+   */
+  getNextPageUrl() {
+    if (this.hasMorePages) {
+      return this.getUrl(this.currentPage + 1);
+    }
+    return null;
+  }
+  /**
+   * Returns URL for the previous page
+   */
+  getPreviousPageUrl() {
+    if (this.currentPage > 1) {
+      return this.getUrl(this.currentPage - 1);
+    }
+    return null;
+  }
+  /**
+   * Returns url for a given page. Doesn't validate the integrity of the
+   * page
+   */
+  getUrl(page) {
+    const qstring = stringify({ ...this.qs, page: page < 1 ? 1 : page });
+    return `${this.url}?${qstring}`;
+  }
+  /**
+   * Returns an array of urls under a given range
+   */
+  getUrlsForRange(start, end) {
+    const urls = [];
+    for (let index = start; index <= end; index++) {
+      urls.push({ isActive: index === this.currentPage, page: index, url: this.getUrl(index) });
+    }
+    return urls;
+  }
+  /**
+   * Define query string to be appended to the pagination links
+   */
+  queryString(values) {
+    this.qs = values;
+    return this;
+  }
+  /**
+   * Returns JSON representation of the paginated
+   * data
+   */
+  toJSON() {
+    return {
+      data: this.all(),
+      meta: this.getMeta()
+    };
+  }
+  /**
+   * Find if there are more pages to come
+   */
+  get hasMorePages() {
+    return this.lastPage > this.currentPage;
+  }
+  /**
+   * Find if there are enough results to be paginated or not
+   */
+  get hasPages() {
+    return this.lastPage !== 1;
+  }
+  /**
+   * Find if there are total records or not. This is not same as
+   * `isEmpty`.
+   *
+   * The `isEmpty` reports about the current set of results. However, `hasTotal`
+   * reports about the total number of records, regardless of the current.
+   */
+  get hasTotal() {
+    return this.total > 0;
+  }
+  /**
+   * The Last page number
+   */
+  get lastPage() {
+    return Math.max(Math.ceil(this.total / this.perPage), 1);
+  }
+  /**
+   * Casting `total` to a number. Later, we can think of situations
+   * to cast it to a bigint
+   */
+  get total() {
+    return Number(this.totalNumber);
+  }
+}
+
+module.exports = Paginator;