@jlcpcb/core 0.1.0

package/src/converter/value-normalizer.ts

@@ -0,0 +1,262 @@
+/**
+ * Component Value Normalizer
+ * Extracts and normalizes component values from descriptions
+ * "16k Ohm ±1% 0.1W" → "16k"
+ * "100nF 50V X7R" → "100n/50V"
+ */
+
+export type ComponentType = 'resistor' | 'capacitor' | 'inductor' | 'diode' | 'transistor' | 'ic' | 'other';
+
+export interface NormalizedValue {
+  displayValue: string;    // For symbol Value property
+  originalValue: string;   // Keep for Description
+  params?: {
+    value?: string;        // Core value (e.g., "16k", "100n")
+    tolerance?: string;    // e.g., "1%"
+    voltage?: string;      // e.g., "50V"
+    power?: string;        // e.g., "0.25W"
+    current?: string;      // e.g., "2A"
+  };
+}
+
+// Regex patterns for value extraction
+const PATTERNS = {
+  // Resistors: Match value with optional multiplier and unit
+  // "16k", "16kOhm", "16K OHM", "16000", "4.7k", "0R1" (0.1 ohm)
+  resistor: /(\d+(?:\.\d+)?)\s*([kKmMgGrR]?)\s*(?:ohm|Ohm|OHM|Ω|R)?/i,
+
+  // Capacitors: Match value with unit and optional voltage
+  // "100nF 50V", "10uF", "100pF", "1000uF/16V"
+  capacitor: /(\d+(?:\.\d+)?)\s*([pnuμmM]?)[Ff]?\s*(?:[\/\s]*(\d+)\s*[Vv])?/i,
+
+  // Inductors: Match value with unit and optional current
+  // "10uH 2A", "100nH", "4.7mH"
+  inductor: /(\d+(?:\.\d+)?)\s*([nμumM]?)[Hh]\s*(?:[\/\s]*(\d+(?:\.\d+)?)\s*[Aa])?/i,
+
+  // Voltage rating extraction
+  voltage: /(\d+(?:\.\d+)?)\s*[Vv]/,
+
+  // Tolerance extraction
+  tolerance: /[±]?\s*(\d+(?:\.\d+)?)\s*%/,
+
+  // Power rating extraction
+  power: /(\d+(?:\.\d+)?)\s*[Ww]/,
+
+  // Current rating extraction
+  current: /(\d+(?:\.\d+)?)\s*[Aa]/,
+};
+
+// Multiplier normalization
+const MULTIPLIER_MAP: Record<string, string> = {
+  '': '',
+  'r': '',    // 0R1 style (0.1 ohm)
+  'R': '',
+  'k': 'k',
+  'K': 'k',
+  'm': 'm',   // milli for caps/inductors, mega for resistors (context dependent)
+  'M': 'M',
+  'g': 'G',
+  'G': 'G',
+  'p': 'p',
+  'n': 'n',
+  'u': 'u',
+  'μ': 'u',
+};
+
+/**
+ * Detect component type from prefix and category
+ */
+export function detectComponentType(prefix: string, category?: string): ComponentType {
+  const p = prefix.toUpperCase();
+
+  switch (p) {
+    case 'R':
+      return 'resistor';
+    case 'C':
+      return 'capacitor';
+    case 'L':
+      return 'inductor';
+    case 'D':
+      return 'diode';
+    case 'Q':
+      return 'transistor';
+    case 'U':
+      return 'ic';
+    default:
+      // Fallback to category-based detection
+      if (category) {
+        const cat = category.toLowerCase();
+        if (cat.includes('resistor')) return 'resistor';
+        if (cat.includes('capacitor')) return 'capacitor';
+        if (cat.includes('inductor')) return 'inductor';
+        if (cat.includes('diode')) return 'diode';
+        if (cat.includes('transistor')) return 'transistor';
+        if (cat.includes('ic') || cat.includes('microcontroller')) return 'ic';
+      }
+      return 'other';
+  }
+}
+
+/**
+ * Normalize resistor value
+ */
+function normalizeResistor(description: string): NormalizedValue {
+  const match = description.match(PATTERNS.resistor);
+
+  if (!match) {
+    return { displayValue: description, originalValue: description };
+  }
+
+  const [, value, multiplier] = match;
+  const normalizedMultiplier = MULTIPLIER_MAP[multiplier] || '';
+
+  // Handle "0R1" style notation (0.1 ohm)
+  if (multiplier.toLowerCase() === 'r') {
+    const numValue = parseFloat(value);
+    if (numValue === 0) {
+      // "0R1" = 0.1 ohm - extract the digit after R from original
+      const zeroRMatch = description.match(/0[rR](\d)/);
+      if (zeroRMatch) {
+        return {
+          displayValue: `0.${zeroRMatch[1]}`,
+          originalValue: description,
+          params: { value: `0.${zeroRMatch[1]}` },
+        };
+      }
+    }
+  }
+
+  const displayValue = `${value}${normalizedMultiplier}`;
+
+  // Extract additional params
+  const toleranceMatch = description.match(PATTERNS.tolerance);
+  const powerMatch = description.match(PATTERNS.power);
+
+  return {
+    displayValue,
+    originalValue: description,
+    params: {
+      value: displayValue,
+      tolerance: toleranceMatch ? `${toleranceMatch[1]}%` : undefined,
+      power: powerMatch ? `${powerMatch[1]}W` : undefined,
+    },
+  };
+}
+
+/**
+ * Normalize capacitor value
+ */
+function normalizeCapacitor(description: string): NormalizedValue {
+  const match = description.match(PATTERNS.capacitor);
+
+  if (!match) {
+    return { displayValue: description, originalValue: description };
+  }
+
+  const [, value, unit, voltage] = match;
+  const normalizedUnit = MULTIPLIER_MAP[unit] || unit;
+
+  let displayValue = `${value}${normalizedUnit}`;
+
+  // Add voltage if present
+  if (voltage) {
+    displayValue += `/${voltage}V`;
+  }
+
+  return {
+    displayValue,
+    originalValue: description,
+    params: {
+      value: `${value}${normalizedUnit}`,
+      voltage: voltage ? `${voltage}V` : undefined,
+    },
+  };
+}
+
+/**
+ * Normalize inductor value
+ */
+function normalizeInductor(description: string): NormalizedValue {
+  const match = description.match(PATTERNS.inductor);
+
+  if (!match) {
+    return { displayValue: description, originalValue: description };
+  }
+
+  const [, value, unit, current] = match;
+  const normalizedUnit = MULTIPLIER_MAP[unit] || unit;
+
+  let displayValue = `${value}${normalizedUnit}H`;
+
+  // Add current if present
+  if (current) {
+    displayValue += `/${current}A`;
+  }
+
+  return {
+    displayValue,
+    originalValue: description,
+    params: {
+      value: `${value}${normalizedUnit}H`,
+      current: current ? `${current}A` : undefined,
+    },
+  };
+}
+
+/**
+ * Main normalization function
+ * Returns normalized value based on component type
+ */
+export function normalizeValue(
+  description: string,
+  type: ComponentType
+): NormalizedValue {
+  // Clean input
+  const cleaned = description.trim();
+
+  // Skip normalization for ICs and complex parts - keep original name
+  if (type === 'ic' || type === 'other') {
+    return { displayValue: cleaned, originalValue: cleaned };
+  }
+
+  switch (type) {
+    case 'resistor':
+      return normalizeResistor(cleaned);
+    case 'capacitor':
+      return normalizeCapacitor(cleaned);
+    case 'inductor':
+      return normalizeInductor(cleaned);
+    case 'diode':
+    case 'transistor':
+      // For diodes and transistors, keep the part number but clean it up
+      // Remove common prefixes/suffixes that aren't part of the name
+      return { displayValue: cleaned, originalValue: cleaned };
+    default:
+      return { displayValue: cleaned, originalValue: cleaned };
+  }
+}
+
+/**
+ * Extract value from component name or description
+ * Tries multiple strategies to find a meaningful value
+ */
+export function extractDisplayValue(
+  name: string,
+  description: string | undefined,
+  prefix: string,
+  category?: string
+): string {
+  const type = detectComponentType(prefix, category);
+
+  // For passives, prefer to extract from description which has more detail
+  if (description && (type === 'resistor' || type === 'capacitor' || type === 'inductor')) {
+    const normalized = normalizeValue(description, type);
+    if (normalized.displayValue !== description) {
+      return normalized.displayValue;
+    }
+  }
+
+  // Fallback to name
+  const normalized = normalizeValue(name, type);
+  return normalized.displayValue;
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+/**
+ * jlc-core
+ * Core library for JLC/EasyEDA component sourcing and KiCad conversion
+ */
+
+// Services (high-level API)
+export * from './services/index.js';
+
+// API clients (low-level)
+export * from './api/index.js';
+
+// Converters (low-level)
+export * from './converter/index.js';
+
+// Types
+export * from './types/index.js';
+
+// Utils
+export * from './utils/index.js';
+
+// Constants
+export * from './constants/index.js';
+
+// Parsers
+export * from './parsers/index.js';