mechanical-tolerance-calculator 1.0.1 → 1.0.3

package/index.js

@@ -1,5 +1,140 @@
-function helloNPM() {
-  return "HELLO NPM";
+const tolerances = require("./Tolerances.json");
+
+/**
+ * Returns all tolerances for the given material type.
+ * @description
+ * The function checks the provided material type string to determine
+ * which category of tolerances to return. It supports 'housing', 'shaft',
+ * and 'shell' as valid material types. If the input is invalid or does not
+ * match any known category, an error message is returned.
+ * @param {string} materialType
+ * @returns {object} An object containing the relevant tolerances or an error message.
+ */
+function getAllTolerancesFor(materialType) {
+  const validatedMaterialType = validateMaterialType(materialType);
+
+  const trimmedMaterialType = validatedMaterialType.trim().toLowerCase(); // normalize input
+  if (trimmedMaterialType.includes("housing")) {
+    // includes to allow variations like "housing bore"
+    return returnTolerancesFor("housingBores"); // return relevant tolerances
+  } else if (trimmedMaterialType.includes("shaft")) {
+    // includes to allow variations like "shaft rod"
+    return returnTolerancesFor("shafts"); // return relevant tolerances
+  } else if (trimmedMaterialType.includes("shell")) {
+    // includes to allow variations like "shell bore"
+    return returnTolerancesFor("shellBores"); // return relevant tolerances
+  } else {
+    return {
+      error: `Unknown material type: ${materialType}. Valid types are 'housing', 'shaft', or 'shell'.`, // error for invalid typefac
+    };
+  }
+}
+
+/**
+ * Returns Camco Standard specification and tolerances for the given material type.
+ * @description
+ * The function checks the provided material type string to determine
+ * which category of camco standard tolerances to return. It supports 'housing', 'shaft',
+ * and 'shell' as valid material types. If the input is invalid or does not
+ * match any known category, an error message is returned.
+ * @param {string} materialType
+ * @returns {object} An object containing the relevant tolerances or an error message.
+ */
+function getCamcoStandardTolerancesFor(materialType) {
+  const validatedMaterialType = validateMaterialType(materialType);
+
+  const trimmedMaterialType = validatedMaterialType.trim().toLowerCase();
+
+  if (trimmedMaterialType.includes("housing")) {
+    return returnTolerancesFor("housingBores", "H8");
+  } else if (trimmedMaterialType.includes("shell")) {
+    return returnTolerancesFor("shellBores", "H9");
+  } else if (trimmedMaterialType.includes("shaft")) {
+    return returnTolerancesFor("shafts", "h9");
+  } else {
+    return {
+      error: `Unknown material type: ${materialType}. Valid types are 'housing', 'shaft', or 'shell'.`,
+    };
+  }
+}
+
+function validateMaterialType(materialType) {
+  if (typeof materialType != "string") {
+    return { error: "Material type must be a string." };
+  }
+
+  if (
+    materialType == undefined ||
+    materialType == null ||
+    materialType.trim() === ""
+  ) {
+    return { error: "Material type is required and cannot be empty." };
+  }
+
+  return materialType;
+}
+
+function returnTolerancesFor(executableMaterialType, spec = "") {
+  if (spec) {
+    const allTolerances = tolerances[executableMaterialType];
+    if (!Object.keys(allTolerances).includes(spec)) {
+      return {
+        error: `Currently available specifications are ${Object.keys(
+          allTolerances
+        )}`,
+      };
+    }
+    return {
+      type: executableMaterialType,
+      specification: tolerances[executableMaterialType][spec],
+    };
+  }
+
+  return {
+    type: executableMaterialType,
+    specifications: tolerances[executableMaterialType],
+  };
+}
+
+function parseNominalFromMeasurement(measurement) {
+  const nominalString = measurement.toString();
+  let nominal = "";
+  for (let index = 0; index < nominalString.length; index++) {
+    if (nominalString[index] === ".") {
+      break;
+    }
+    nominal += nominalString[index];
+  }
+  return parseInt(nominal);
+}
+
+function checkOneMeasurementFor(materialType, measurement) {
+  const camcoStandardTolerances = getCamcoStandardTolerancesFor(materialType);
+  let nominal = parseNominalFromMeasurement(measurement);
+  let matchedSpec = {};
+  if (camcoStandardTolerances.type === "shafts") {
+    const shaftNominal = nominal + 1;
+    const specs = camcoStandardTolerances["specification"];
+    Array.from(specs).forEach((spec) => {
+      if (
+        shaftNominal > spec.minimum_diameter &&
+        shaftNominal <= spec.maximum_diameter
+      ) {
+        matchedSpec = spec;
+      }
+    });
+
+    const check = Number(matchedSpec.upper_deviation).toFixed(3);
+    console.log(check);
+  }
+  console.log(nominal);
+
+  console.log(matchedSpec);
 }
 
-module.exports = helloNPM;
+module.exports = {
+  getAllTolerancesFor,
+  getCamcoStandardTolerancesFor,
+  parseNominalFromMeasurement,
+  checkOneMeasurementFor,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mechanical-tolerance-calculator",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Calculates international standard specification and  tolerances for bores, round bars and metals of mechanical units. For examples; H7, H8, H9, h8, h9 specifications and IT5/IT6 tolerances.",
   "main": "index.js",
   "scripts": {

package/Readme.md

@@ -1,91 +0,0 @@
-🧮 Mechanical Tolerance Calculator
-
-Mechanical Tolerance Calculator is a lightweight JavaScript utility for calculating international standard specifications and tolerances for bores, round bars, and metallic mechanical units.
-It supports common engineering fit and tolerance designations such as H7, H8, H9, h8, h9, and IT5–IT6 according to ISO/ANSI standards.
-
-🚀 Features
-
-Calculates standard tolerances (IT grades) and shaft/hole deviations.
-
-Supports ISO system of limits and fits (e.g., H7/h6, H8/f7).
-
-Works for both bores (holes) and shafts (round bars).
-
-Returns tolerance ranges, upper/lower deviations, and clearance/interference fit results.
-
-Lightweight and dependency-free.
-
-📦 Installation
-npm install mechanical-tolerance-calculator
-
-or using yarn:
-
-yarn add mechanical-tolerance-calculator
-
-🧰 Usage
-import { calculateTolerance } from "mechanical-tolerance-calculator";
-
-// Example: Hole tolerance for H7, nominal size 50 mm
-const hole = calculateTolerance("H7", 50);
-console.log(hole);
-/_
-{
-type: "hole",
-nominal: 50,
-designation: "H7",
-upperDeviation: 0.025,
-lowerDeviation: 0.000,
-tolerance: 0.025,
-ITGrade: 7
-}
-_/
-
-// Example: Shaft tolerance for h6, nominal size 50 mm
-const shaft = calculateTolerance("h6", 50);
-console.log(shaft);
-/_
-{
-type: "shaft",
-nominal: 50,
-designation: "h6",
-upperDeviation: 0.000,
-lowerDeviation: -0.016,
-tolerance: 0.016,
-ITGrade: 6
-}
-_/
-
-⚙️ API Reference
-calculateTolerance(designation, nominalSize)
-Parameter Type Description
-designation string ISO/ANSI tolerance designation (e.g. "H7", "h6", "IT6")
-nominalSize number Nominal dimension in millimeters
-
-Returns:
-An object containing tolerance values and deviation limits.
-
-📚 Standards Referenced
-
-ISO 286-1: Geometrical Product Specifications (GPS) — Limits and Fits
-
-ANSI B4.2: Preferred Metric Limits and Fits
-
-🧪 Example Applications
-
-Mechanical part design and inspection tools
-
-CAD/CAM automation scripts
-
-Manufacturing tolerance checkers
-
-Educational or research tools for mechanical engineering
-
-🧑‍💻 Contributing
-
-Contributions, issues, and feature requests are welcome!
-Feel free to open a GitHub issue
-or submit a pull request.
-
-📄 License
-
-MIT © 2025 Ajay Ghimire