mechanical-tolerance-calculator 1.0.0 → 1.0.2

package/index.js

@@ -1,5 +1,137 @@
-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;
+      }
+    });
+  }
+  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.0",
+  "version": "1.0.2",
   "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": {