@scalar/helpers 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @scalar/helpers
 
+## 0.2.0
+
+### Minor Changes
+
+- [#7477](https://github.com/scalar/scalar/pull/7477) [`9ec8adf`](https://github.com/scalar/scalar/commit/9ec8adfea017333dee5bc3949104232f7dc57f4a) Thanks [@DemonHa](https://github.com/DemonHa)! - fix: correctly sort documents on the workspace
+
+## 0.1.3
+
+### Patch Changes
+
+- [#7387](https://github.com/scalar/scalar/pull/7387) [`bfd814a`](https://github.com/scalar/scalar/commit/bfd814a4219660face190041cc4845182b56ab03) Thanks [@geoffgscott](https://github.com/geoffgscott)! - hotfix: patch exports from build tooling bug
+
+- [#7416](https://github.com/scalar/scalar/pull/7416) [`86f028d`](https://github.com/scalar/scalar/commit/86f028deb0b456f923edd261f5f4b0fa9b616b7d) Thanks [@amritk](https://github.com/amritk)! - feat: add update method to client v2
+
 ## 0.1.2
 
 ### Patch Changes

package/dist/array/sort-by-order.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Immutably sorts an array based on a given custom order, as specified by a separate list of identifiers.
+ *
+ * Note: Make sure that the identifier is unique for each item in the array.
+ * If the identifier is not unique, only the last occurrence of the identifier will be sorted.
+ * Any other elements will be overridden by the last occurrence of the identifier.
+ *
+ * This function efficiently arranges elements of an input array so that items whose IDs (obtained via the `getId` callback)
+ * match the order array will appear first, strictly in the order specified. Items not found in the order array will be
+ * appended after, maintaining their original order.
+ *
+ * This is a flexible utility: the identifier can be extracted from any data structure via the `getId` callback,
+ * and any primitive (string, number, symbol, etc.) can serve as the identifier type.
+ * Sorting is O(n) with respect to the array size, making it performant even for large arrays.
+ *
+ * @template T - The type of array elements.
+ * @template N - The type of values in the order array and the identifier returned by the getId callback.
+ * @param arr - The array to be sorted.
+ * @param order - Array specifying the desired sequence (contains identifiers returned by getId).
+ * @param getId - A callback to extract the unique identifier from each array element.
+ * @returns A new array sorted according to the order provided, with unmatched elements following.
+ *
+ * @example
+ * // Sorting an array of objects:
+ * const items = [
+ *   { id: 'a', name: 'Alpha' },
+ *   { id: 'b', name: 'Bravo' },
+ *   { id: 'c', name: 'Charlie' }
+ * ];
+ * const order = ['c', 'a'];
+ * const sorted = sortByOrder(items, order, item => item.id);
+ * // Result:
+ * // [
+ * //   { id: 'c', name: 'Charlie' },
+ * //   { id: 'a', name: 'Alpha' },
+ * //   { id: 'b', name: 'Bravo' }
+ * // ]
+ *
+ * @example
+ * // Sorting an array of primitive values:
+ * const input = ['a', 'b', 'c', 'd'];
+ * const order = ['c', 'a'];
+ * sortByOrder(input, order, item => item);
+ * // Result: ['c', 'a', 'b', 'd']
+ */
+export declare function sortByOrder<T, N>(arr: T[], order: N[], getId: (item: T) => N): T[];
+//# sourceMappingURL=sort-by-order.d.ts.map

package/dist/array/sort-by-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by-order.d.ts","sourceRoot":"","sources":["../../src/array/sort-by-order.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAkBlF"}

package/dist/array/sort-by-order.js

@@ -0,0 +1,19 @@
+function sortByOrder(arr, order, getId) {
+  const orderMap = /* @__PURE__ */ new Map();
+  order.forEach((e, idx) => orderMap.set(e, idx));
+  const sorted = [];
+  const untagged = [];
+  arr.forEach((e) => {
+    const sortedIdx = orderMap.get(getId(e));
+    if (sortedIdx === void 0) {
+      untagged.push(e);
+      return;
+    }
+    sorted[sortedIdx] = e;
+  });
+  return [...sorted.filter((it) => it !== void 0), ...untagged];
+}
+export {
+  sortByOrder
+};
+//# sourceMappingURL=sort-by-order.js.map

package/dist/array/sort-by-order.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/array/sort-by-order.ts"],
+  "sourcesContent": ["/**\n * Immutably sorts an array based on a given custom order, as specified by a separate list of identifiers.\n *\n * Note: Make sure that the identifier is unique for each item in the array.\n * If the identifier is not unique, only the last occurrence of the identifier will be sorted.\n * Any other elements will be overridden by the last occurrence of the identifier.\n *\n * This function efficiently arranges elements of an input array so that items whose IDs (obtained via the `getId` callback)\n * match the order array will appear first, strictly in the order specified. Items not found in the order array will be\n * appended after, maintaining their original order.\n *\n * This is a flexible utility: the identifier can be extracted from any data structure via the `getId` callback,\n * and any primitive (string, number, symbol, etc.) can serve as the identifier type.\n * Sorting is O(n) with respect to the array size, making it performant even for large arrays.\n *\n * @template T - The type of array elements.\n * @template N - The type of values in the order array and the identifier returned by the getId callback.\n * @param arr - The array to be sorted.\n * @param order - Array specifying the desired sequence (contains identifiers returned by getId).\n * @param getId - A callback to extract the unique identifier from each array element.\n * @returns A new array sorted according to the order provided, with unmatched elements following.\n *\n * @example\n * // Sorting an array of objects:\n * const items = [\n *   { id: 'a', name: 'Alpha' },\n *   { id: 'b', name: 'Bravo' },\n *   { id: 'c', name: 'Charlie' }\n * ];\n * const order = ['c', 'a'];\n * const sorted = sortByOrder(items, order, item => item.id);\n * // Result:\n * // [\n * //   { id: 'c', name: 'Charlie' },\n * //   { id: 'a', name: 'Alpha' },\n * //   { id: 'b', name: 'Bravo' }\n * // ]\n *\n * @example\n * // Sorting an array of primitive values:\n * const input = ['a', 'b', 'c', 'd'];\n * const order = ['c', 'a'];\n * sortByOrder(input, order, item => item);\n * // Result: ['c', 'a', 'b', 'd']\n */\nexport function sortByOrder<T, N>(arr: T[], order: N[], getId: (item: T) => N): T[] {\n  // Map the order to keep a single lookup table\n  const orderMap = new Map<N, number>()\n  order.forEach((e, idx) => orderMap.set(e, idx))\n\n  const sorted: T[] = []\n  const untagged: T[] = []\n\n  arr.forEach((e) => {\n    const sortedIdx = orderMap.get(getId(e))\n    if (sortedIdx === undefined) {\n      untagged.push(e)\n      return\n    }\n    sorted[sortedIdx] = e\n  })\n\n  return [...sorted.filter((it) => it !== undefined), ...untagged]\n}\n"],
+  "mappings": "AA6CO,SAAS,YAAkB,KAAU,OAAY,OAA4B;AAElF,QAAM,WAAW,oBAAI,IAAe;AACpC,QAAM,QAAQ,CAAC,GAAG,QAAQ,SAAS,IAAI,GAAG,GAAG,CAAC;AAE9C,QAAM,SAAc,CAAC;AACrB,QAAM,WAAgB,CAAC;AAEvB,MAAI,QAAQ,CAAC,MAAM;AACjB,UAAM,YAAY,SAAS,IAAI,MAAM,CAAC,CAAC;AACvC,QAAI,cAAc,QAAW;AAC3B,eAAS,KAAK,CAAC;AACf;AAAA,IACF;AACA,WAAO,SAAS,IAAI;AAAA,EACtB,CAAC;AAED,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC,OAAO,OAAO,MAAS,GAAG,GAAG,QAAQ;AACjE;",
+  "names": []
+}

package/dist/object/prevent-pollution.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Validates that a key is safe to use and does not pose a prototype pollution risk.
+ * Throws an error if a dangerous key is detected.
+ *
+ * @param key - The key to validate
+ * @param context - Optional context string to help identify where the validation failed
+ * @throws {Error} If the key matches a known prototype pollution vector
+ *
+ * @example
+ * ```ts
+ * preventPollution('__proto__') // throws Error
+ * preventPollution('safeName') // passes
+ * preventPollution('constructor', 'operation update') // throws Error with context
+ * ```
+ */
+export declare const preventPollution: (key: string, context?: string) => void;
+//# sourceMappingURL=prevent-pollution.d.ts.map

package/dist/object/prevent-pollution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prevent-pollution.d.ts","sourceRoot":"","sources":["../../src/object/prevent-pollution.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,IAQhE,CAAA"}

package/dist/object/prevent-pollution.js

@@ -0,0 +1,11 @@
+const PROTOTYPE_POLLUTION_KEYS = ["__proto__", "prototype", "constructor"];
+const preventPollution = (key, context) => {
+  if (PROTOTYPE_POLLUTION_KEYS.includes(key)) {
+    const errorMessage = context ? `Prototype pollution key detected: "${key}" in ${context}` : `Prototype pollution key detected: "${key}"`;
+    throw new Error(errorMessage);
+  }
+};
+export {
+  preventPollution
+};
+//# sourceMappingURL=prevent-pollution.js.map

package/dist/object/prevent-pollution.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/object/prevent-pollution.ts"],
+  "sourcesContent": ["/**\n * List of dangerous keys that can be used for prototype pollution attacks.\n * These keys should never be used as property names in dynamic object operations.\n */\nconst PROTOTYPE_POLLUTION_KEYS = ['__proto__', 'prototype', 'constructor'] as const\n\n/**\n * Validates that a key is safe to use and does not pose a prototype pollution risk.\n * Throws an error if a dangerous key is detected.\n *\n * @param key - The key to validate\n * @param context - Optional context string to help identify where the validation failed\n * @throws {Error} If the key matches a known prototype pollution vector\n *\n * @example\n * ```ts\n * preventPollution('__proto__') // throws Error\n * preventPollution('safeName') // passes\n * preventPollution('constructor', 'operation update') // throws Error with context\n * ```\n */\nexport const preventPollution = (key: string, context?: string): void => {\n  if (PROTOTYPE_POLLUTION_KEYS.includes(key as never)) {\n    const errorMessage = context\n      ? `Prototype pollution key detected: \"${key}\" in ${context}`\n      : `Prototype pollution key detected: \"${key}\"`\n\n    throw new Error(errorMessage)\n  }\n}\n"],
+  "mappings": "AAIA,MAAM,2BAA2B,CAAC,aAAa,aAAa,aAAa;AAiBlE,MAAM,mBAAmB,CAAC,KAAa,YAA2B;AACvE,MAAI,yBAAyB,SAAS,GAAY,GAAG;AACnD,UAAM,eAAe,UACjB,sCAAsC,GAAG,QAAQ,OAAO,KACxD,sCAAsC,GAAG;AAE7C,UAAM,IAAI,MAAM,YAAY;AAAA,EAC9B;AACF;",
+  "names": []
+}

package/package.json

@@ -14,7 +14,7 @@
     "helpers",
     "js"
   ],
-  "version": "0.1.2",
+  "version": "0.2.0",
   "engines": {
     "node": ">=20"
   },
@@ -27,6 +27,11 @@
       "types": "./dist/array/*.d.ts",
       "default": "./dist/array/*.js"
     },
+    "./crypto/*": {
+      "import": "./dist/crypto/*.js",
+      "types": "./dist/crypto/*.d.ts",
+      "default": "./dist/crypto/*.js"
+    },
     "./dom/*": {
       "import": "./dist/dom/*.js",
       "types": "./dist/dom/*.d.ts",
@@ -76,11 +81,6 @@
       "import": "./dist/url/*.js",
       "types": "./dist/url/*.d.ts",
       "default": "./dist/url/*.js"
-    },
-    "./crypto/*": {
-      "import": "./dist/crypto/*.js",
-      "types": "./dist/crypto/*.d.ts",
-      "default": "./dist/crypto/*.js"
     }
   },
   "files": [
@@ -91,7 +91,7 @@
     "jsdom": "26.1.0",
     "vite": "7.1.11",
     "vitest": "3.2.4",
-    "@scalar/build-tooling": "0.3.0"
+    "@scalar/build-tooling": "0.3.1"
   },
   "scripts": {
     "build": "scalar-build-esbuild",