mechanical-tolerance-calculator 1.0.3 → 1.0.4

package/index.js

@@ -96,40 +96,185 @@ function returnTolerancesFor(executableMaterialType, spec = "") {
   };
 }
 
-function parseNominalFromMeasurement(measurement) {
-  const nominalString = measurement.toString();
-  let nominal = "";
-  for (let index = 0; index < nominalString.length; index++) {
-    if (nominalString[index] === ".") {
-      break;
-    }
-    nominal += nominalString[index];
+function parseNominalFromMeasurement(measurement, materialType) {
+  // For shafts: upper_deviation is 0, so measurement ≤ nominal
+  // Therefore, nominal must be ceiling of measurement
+  if (materialType === "shafts") {
+    return Math.ceil(measurement);
+  }
+
+  // For bores: lower_deviation is 0, so measurement ≥ nominal
+  // Therefore, nominal must be floor of measurement
+  if (materialType === "housingBores" || materialType === "shellBores") {
+    return Math.floor(measurement);
   }
-  return parseInt(nominal);
+
+  // Default: round to nearest
+  return Math.round(measurement);
+}
+
+const MATERIAL_TYPE_CONFIG = {
+  shafts: {
+    specification: "h9",
+    itGrade: "IT5",
+    rangeMatch: (nominal, spec) =>
+      nominal > spec.minimum_diameter && nominal <= spec.maximum_diameter,
+  },
+  housingBores: {
+    specification: "H8",
+    itGrade: "IT6",
+    rangeMatch: (nominal, spec) =>
+      nominal >= spec.minimum_diameter && nominal < spec.maximum_diameter,
+  },
+  shellBores: {
+    specification: "H9",
+    itGrade: "IT6",
+    rangeMatch: (nominal, spec) =>
+      nominal >= spec.minimum_diameter && nominal < spec.maximum_diameter,
+  },
+};
+
+function findMatchingSpec(nominal, specs, rangeMatchFn) {
+  return specs.find((spec) => rangeMatchFn(nominal, spec)) || null;
+}
+
+function calculateComputedBounds(nominal, spec) {
+  return {
+    upperBound: parseComputedBound(nominal, spec.upper_deviation, 3),
+    lowerBound: parseComputedBound(nominal, spec.lower_deviation, 3),
+  };
+}
+
+function calculateUncomputedBounds(nominal, spec) {
+  return {
+    upperBound: parseUncomputedBound(nominal, spec.upper_deviation),
+    lowerBound: parseUncomputedBound(nominal, spec.lower_deviation),
+  };
+}
+
+function checkMeetsSpecification(measurement, bounds) {
+  const measure = parseStringFloat(measurement);
+  const upper = parseStringFloat(bounds.upperBound);
+  const lower = parseStringFloat(bounds.lowerBound);
+
+  return measure >= lower && measure <= upper;
+}
+
+function processMeasurement(materialType, measurement, tolerances) {
+  const config = MATERIAL_TYPE_CONFIG[materialType];
+
+  if (!config) {
+    return {
+      error: true,
+      message: `Unknown material type: ${materialType}`,
+    };
+  }
+
+  // Calculate nominal diameter
+  const nominal = parseNominalFromMeasurement(measurement, materialType);
+
+  // Find matching specification
+  const matchedSpec = findMatchingSpec(
+    nominal,
+    tolerances.specification,
+    config.rangeMatch
+  );
+
+  if (!matchedSpec) {
+    return {
+      error: true,
+      message: `No specification found for nominal diameter: ${nominal}`,
+      nominal,
+    };
+  }
+
+  // Calculate bounds
+  const computedBounds = calculateComputedBounds(nominal, matchedSpec);
+  const uncomputedBounds = calculateUncomputedBounds(nominal, matchedSpec);
+
+  // Check if measurement meets specification
+  const meetsSpec = checkMeetsSpecification(measurement, computedBounds);
+
+  return {
+    measurement: parseStringFloat(measurement),
+    nominal,
+    specification: config.specification,
+    IT_grade: config.itGrade,
+    computed_specification_bounds: computedBounds,
+    uncomputed_specification_bounds: uncomputedBounds,
+    meet_specification: meetsSpec,
+    meets_IT_tolerance: meetsSpec,
+    matched_spec: matchedSpec,
+  };
 }
 
 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);
+
+  if (camcoStandardTolerances.error) {
+    return camcoStandardTolerances;
   }
-  console.log(nominal);
 
-  console.log(matchedSpec);
+  if (typeof measurement !== "number" || isNaN(measurement)) {
+    return {
+      error: true,
+      message: "Invalid measurement value",
+    };
+  }
+
+  return processMeasurement(
+    camcoStandardTolerances.type,
+    measurement,
+    camcoStandardTolerances
+  );
+}
+
+function parseComputedBound(base, value, decimalCount) {
+  return Number(base + parseStringFloat(value)).toFixed(decimalCount);
+}
+
+function parseUncomputedBound(value1, value2) {
+  if (value2.startsWith("-")) {
+    return (
+      parseToFixedThreeString(value1) +
+      " - " +
+      parseToFixedThreeString(value2.slice(1, value2.length))
+    );
+  }
+
+  return (
+    parseToFixedThreeString(value1) + " + " + parseToFixedThreeString(value2)
+  );
+}
+
+function parseToFixedThreeString(value) {
+  if (typeof value === "number") {
+    return value.toFixed(3);
+  }
+  return value;
+}
+
+/**
+ * Converts string float values to actual float numbers
+ * @param {string} value - The string representation of a float number
+ * @returns {number} - The parsed float number
+ */
+function parseStringFloat(value) {
+  // Handle edge cases
+  if (value === null || value === undefined) {
+    return 0;
+  }
+
+  // If it's already a number, return it
+  if (typeof value === "number") {
+    return value;
+  }
+
+  // Convert string to float
+  const parsed = parseFloat(value);
+
+  // Return 0 if parsing fails (NaN)
+  return isNaN(parsed) ? 0 : parsed;
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mechanical-tolerance-calculator",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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": {