@library/math 0.0.0-stage → 0.0.8

package/coverage/lcov-report/sorter.js

@@ -0,0 +1,205 @@
+/* eslint-disable */
+var addSorting = (function () {
+  "use strict";
+  var cols,
+    currentSort = {
+      index: 0,
+      desc: false,
+    };
+
+  // returns the summary table element
+  function getTable() {
+    return document.querySelector(".coverage-summary");
+  }
+  // returns the thead element of the summary table
+  function getTableHeader() {
+    return getTable().querySelector("thead tr");
+  }
+  // returns the tbody element of the summary table
+  function getTableBody() {
+    return getTable().querySelector("tbody");
+  }
+  // returns the th element for nth column
+  function getNthColumn(n) {
+    return getTableHeader().querySelectorAll("th")[n];
+  }
+
+  function onFilterInput() {
+    const searchValue = document.getElementById("fileSearch").value;
+    const rows = document.getElementsByTagName("tbody")[0].children;
+
+    // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+    // it will be treated as a plain text search
+    let searchRegex;
+    try {
+      searchRegex = new RegExp(searchValue, "i"); // 'i' for case-insensitive
+    } catch (error) {
+      searchRegex = null;
+    }
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      let isMatch = false;
+
+      if (searchRegex) {
+        // If a valid regex was created, use it for matching
+        isMatch = searchRegex.test(row.textContent);
+      } else {
+        // Otherwise, fall back to the original plain text search
+        isMatch = row.textContent.toLowerCase().includes(searchValue.toLowerCase());
+      }
+
+      row.style.display = isMatch ? "" : "none";
+    }
+  }
+
+  // loads the search box
+  function addSearchBox() {
+    var template = document.getElementById("filterTemplate");
+    var templateClone = template.content.cloneNode(true);
+    templateClone.getElementById("fileSearch").oninput = onFilterInput;
+    template.parentElement.appendChild(templateClone);
+  }
+
+  // loads all columns
+  function loadColumns() {
+    var colNodes = getTableHeader().querySelectorAll("th"),
+      colNode,
+      cols = [],
+      col,
+      i;
+
+    for (i = 0; i < colNodes.length; i += 1) {
+      colNode = colNodes[i];
+      col = {
+        key: colNode.getAttribute("data-col"),
+        sortable: !colNode.getAttribute("data-nosort"),
+        type: colNode.getAttribute("data-type") || "string",
+      };
+      cols.push(col);
+      if (col.sortable) {
+        col.defaultDescSort = col.type === "number";
+        colNode.innerHTML = colNode.innerHTML + '<span class="sorter"></span>';
+      }
+    }
+    return cols;
+  }
+  // attaches a data attribute to every tr element with an object
+  // of data values keyed by column name
+  function loadRowData(tableRow) {
+    var tableCols = tableRow.querySelectorAll("td"),
+      colNode,
+      col,
+      data = {},
+      i,
+      val;
+    for (i = 0; i < tableCols.length; i += 1) {
+      colNode = tableCols[i];
+      col = cols[i];
+      val = colNode.getAttribute("data-value");
+      if (col.type === "number") {
+        val = Number(val);
+      }
+      data[col.key] = val;
+    }
+    return data;
+  }
+  // loads all row data
+  function loadData() {
+    var rows = getTableBody().querySelectorAll("tr"),
+      i;
+
+    for (i = 0; i < rows.length; i += 1) {
+      rows[i].data = loadRowData(rows[i]);
+    }
+  }
+  // sorts the table using the data for the ith column
+  function sortByIndex(index, desc) {
+    var key = cols[index].key,
+      sorter = function (a, b) {
+        a = a.data[key];
+        b = b.data[key];
+        return a < b ? -1 : a > b ? 1 : 0;
+      },
+      finalSorter = sorter,
+      tableBody = document.querySelector(".coverage-summary tbody"),
+      rowNodes = tableBody.querySelectorAll("tr"),
+      rows = [],
+      i;
+
+    if (desc) {
+      finalSorter = function (a, b) {
+        return -1 * sorter(a, b);
+      };
+    }
+
+    for (i = 0; i < rowNodes.length; i += 1) {
+      rows.push(rowNodes[i]);
+      tableBody.removeChild(rowNodes[i]);
+    }
+
+    rows.sort(finalSorter);
+
+    for (i = 0; i < rows.length; i += 1) {
+      tableBody.appendChild(rows[i]);
+    }
+  }
+  // removes sort indicators for current column being sorted
+  function removeSortIndicators() {
+    var col = getNthColumn(currentSort.index),
+      cls = col.className;
+
+    cls = cls.replace(/ sorted$/, "").replace(/ sorted-desc$/, "");
+    col.className = cls;
+  }
+  // adds sort indicators for current column being sorted
+  function addSortIndicators() {
+    getNthColumn(currentSort.index).className += currentSort.desc ? " sorted-desc" : " sorted";
+  }
+  // adds event listeners for all sorter widgets
+  function enableUI() {
+    var i,
+      el,
+      ithSorter = function ithSorter(i) {
+        var col = cols[i];
+
+        return function () {
+          var desc = col.defaultDescSort;
+
+          if (currentSort.index === i) {
+            desc = !currentSort.desc;
+          }
+          sortByIndex(i, desc);
+          removeSortIndicators();
+          currentSort.index = i;
+          currentSort.desc = desc;
+          addSortIndicators();
+        };
+      };
+    for (i = 0; i < cols.length; i += 1) {
+      if (cols[i].sortable) {
+        // add the click event handler on the th so users
+        // dont have to click on those tiny arrows
+        el = getNthColumn(i).querySelector(".sorter").parentElement;
+        if (el.addEventListener) {
+          el.addEventListener("click", ithSorter(i));
+        } else {
+          el.attachEvent("onclick", ithSorter(i));
+        }
+      }
+    }
+  }
+  // adds sorting functionality to the UI
+  return function () {
+    if (!getTable()) {
+      return;
+    }
+    cols = loadColumns();
+    loadData();
+    addSearchBox();
+    addSortIndicators();
+    enableUI();
+  };
+})();
+
+window.addEventListener("load", addSorting);

package/coverage/lcov.info

@@ -0,0 +1,21 @@
+TN:
+SF:src/clamp.ts
+FN:15,clamp
+FNF:1
+FNH:1
+FNDA:5,clamp
+DA:16,5
+LF:1
+LH:1
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:src/index.ts
+FNF:0
+FNH:0
+LF:0
+LH:0
+BRF:0
+BRH:0
+end_of_record

package/dist/cjs/index.cjs

@@ -0,0 +1 @@
+"use strict";var t=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var c=(r,m)=>{for(var n in m)t(r,n,{get:m[n],enumerable:!0})},x=(r,m,n,u)=>{if(m&&typeof m=="object"||typeof m=="function")for(let e of o(m))!p.call(r,e)&&e!==n&&t(r,e,{get:()=>m[e],enumerable:!(u=b(m,e))||u.enumerable});return r};var f=r=>x(t({},"__esModule",{value:!0}),r);var h={};c(h,{clamp:()=>a});module.exports=f(h);function a(r,m,n){return Math.min(Math.max(r,m),n)}0&&(module.exports={clamp});

package/dist/cjs/index.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @param {number} value The number to clamp.
+ * @param {number} min The lower bound.
+ * @param {number} max The upper bound.
+ * @returns {number} The clamped number.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+declare function clamp(value: number, min: number, max: number): number;
+
+export { clamp };

package/dist/esm/chunk-KIYOP373.js

@@ -0,0 +1 @@
+function e(n,m,r){return Math.min(Math.max(n,m),r)}export{e as a};

package/dist/esm/clamp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {number} value The number to clamp.
+ * @param {number} min The lower bound.
+ * @param {number} max The upper bound.
+ * @returns {number} The clamped number.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+declare function clamp(value: number, min: number, max: number): number;
+
+export { clamp };

package/dist/esm/clamp.js

@@ -0,0 +1 @@
+import{a}from"./chunk-KIYOP373.js";export{a as clamp};

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export { clamp } from './clamp.js';

package/dist/esm/index.js

@@ -0,0 +1 @@
+import{a as m}from"./chunk-KIYOP373.js";export{m as clamp};

package/llms.txt

@@ -0,0 +1,42 @@
+<!-- Generated by `yarn docs`. Do not edit by hand. -->
+# @library/math
+
+> A collection of math utilities for TypeScript.
+
+Install:
+
+```console
+npm install @library/math
+```
+
+All exports are named ESM/CJS exports, importable as:
+
+```ts
+import { clamp } from "@library/math";
+```
+
+## API
+
+### clamp
+
+Clamp a number between a lower and upper bound.
+
+```ts
+function clamp(value: number, min: number, max: number): number
+```
+
+Parameters:
+
+- `value`: The number to clamp.
+- `min`: The lower bound.
+- `max`: The upper bound.
+
+Returns: The clamped number.
+
+Example:
+
+```ts
+clamp(5, 0, 10); // 5
+clamp(-5, 0, 10); // 0
+clamp(15, 0, 10); // 10
+```

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@library/math",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.8",
+  "description": "A collection of math utilities for TypeScript.",
+  "type": "module",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/cjs/index.d.cts",
+  "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    }
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "utility"
+  ],
+  "homepage": "https://github.com/yeonjuan/library/tree/main/packages/math#readme",
+  "bugs": {
+    "url": "https://github.com/yeonjuan/library/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yeonjuan/library.git",
+    "directory": "packages/math"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "rimraf dist && tsup --tsconfig tsconfig.build.json",
+    "test": "vitest run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "fea3f714ec98af5ce58621c53734e44a62f881df"
+}

package/src/clamp.spec.ts

@@ -0,0 +1,13 @@
+import { clamp } from "./clamp";
+
+describe("clamp", () => {
+  test.each([
+    [5, 0, 10, 5],
+    [-5, 0, 10, 0],
+    [15, 0, 10, 10],
+    [0, 0, 10, 0],
+    [10, 0, 10, 10],
+  ])("clamp(%i, %i, %i) = %i", (value, min, max, expected) => {
+    expect(clamp(value, min, max)).toBe(expected);
+  });
+});

package/src/clamp.ts

@@ -0,0 +1,17 @@
+/**
+ * Clamp a number between a lower and upper bound.
+ * @param {number} value The number to clamp.
+ * @param {number} min The lower bound.
+ * @param {number} max The upper bound.
+ * @returns {number} The clamped number.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10); // 5
+ * clamp(-5, 0, 10); // 0
+ * clamp(15, 0, 10); // 10
+ * ```
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { clamp } from "./clamp.js";

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.spec.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from "tsup";
+
+const common = {
+  dts: true,
+  clean: true,
+  sourcemap: false,
+  skipNodeModulesBundle: true,
+  minify: true,
+} as const;
+
+export default defineConfig([
+  {
+    ...common,
+    format: ["cjs"],
+    target: ["es2016"],
+    outDir: "dist/cjs",
+    entry: ["src/index.ts"],
+  },
+  {
+    ...common,
+    format: ["esm"],
+    target: ["esnext"],
+    outDir: "dist/esm",
+    entry: ["src/**/*.ts", "!src/**/*.spec.ts"],
+  },
+]);

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+import { baseConfig } from "../../vitest.config.base";
+
+export default defineConfig({
+  test: {
+    ...baseConfig,
+  },
+});