@jjlmoya/utils-home 1.31.0 → 1.32.0

package/src/tool/lightingCalculator/logic.ts

@@ -0,0 +1,119 @@
+export interface LightingInput {
+  roomWidthM: number;
+  roomLengthM: number;
+  roomHeightM: number;
+  roomType: string;
+  bulbType: string;
+  bulbWatt: number;
+  fixtures: number;
+  luxMultiplier: number;
+}
+
+export interface LightingResult {
+  roomArea: number;
+  targetLux: number;
+  requiredLumens: number;
+  bulbLumens: number;
+  currentLux: number;
+  bulbsNeeded: number;
+  optimalBulbs: number;
+  optimalWatt: number;
+  utilizationFactor: number;
+  status: 'optimal' | 'insufficient' | 'excess';
+  luxRatio: number;
+  sensoryContext: string;
+  suggestedProducts: string;
+}
+
+const LUX_TARGETS: Record<string, number> = {
+  living: 150,
+  kitchen: 300,
+  bedroom: 100,
+  bathroom: 200,
+  office: 500,
+  hallway: 100,
+};
+
+const LUMENS_PER_WATT: Record<string, number> = {
+  led: 100,
+  cfl: 60,
+  halogen: 20,
+  incandescent: 15,
+};
+
+const UF_MAP: Record<string, number> = {
+  low: 0.55,
+  medium: 0.50,
+  high: 0.45,
+};
+
+function getUF(roomHeightM: number): number {
+  if (roomHeightM <= 2.5) return UF_MAP.low;
+  if (roomHeightM <= 3.5) return UF_MAP.medium;
+  return UF_MAP.high;
+}
+
+function getSensoryContext(currentLux: number, targetLux: number): string {
+  const ratio = targetLux > 0 ? currentLux / targetLux : 0;
+  if (ratio < 0.3) return 'Like a dark corridor. You need significantly more light.';
+  if (ratio < 0.6) return 'Like a dim restaurant. Good for atmosphere, but not for daily tasks.';
+  if (ratio < 0.9) return 'Getting there. Like a cozy evening, but slightly too dark for comfort.';
+  if (ratio <= 1.3) return 'Perfectly balanced. Like a comfortable living room during the day.';
+  if (ratio <= 1.8) return 'Bright and energetic. Like a well-lit office or kitchen.';
+  return 'Very intense. Like a hospital or studio. Consider dimming for comfort.';
+}
+
+function getSuggestedProducts(
+  bulbsNeeded: number,
+  bulbType: string,
+  optimalWatt: number,
+): string {
+  const typeName = bulbType.toUpperCase();
+  const watt = Math.round(optimalWatt);
+  return `${bulbsNeeded} x ${typeName} ${watt}W bulbs ≈ ${bulbsNeeded * watt * (LUMENS_PER_WATT[bulbType] ?? 100)} lumens total`;
+}
+
+function getStatus(currentLux: number, targetLux: number): 'optimal' | 'insufficient' | 'excess' {
+  if (currentLux < targetLux * 0.9) return 'insufficient';
+  if (currentLux > targetLux * 1.3) return 'excess';
+  return 'optimal';
+}
+
+function getLuxRatio(currentLux: number, targetLux: number): number {
+  return targetLux > 0 ? currentLux / targetLux : 0;
+}
+
+function computeLighting(i: LightingInput) {
+  const roomArea = i.roomWidthM * i.roomLengthM;
+  const baseLux = LUX_TARGETS[i.roomType] ?? 150;
+  const targetLux = Math.round(baseLux * i.luxMultiplier);
+  const utilizationFactor = getUF(i.roomHeightM);
+  const maintenanceFactor = 0.8;
+  const requiredLumens = Math.ceil((targetLux * roomArea) / (utilizationFactor * maintenanceFactor));
+  const bulbLumens = i.bulbWatt * (LUMENS_PER_WATT[i.bulbType] ?? 100);
+  const currentLumens = bulbLumens * i.fixtures;
+  const currentLux = Math.round(currentLumens * utilizationFactor * maintenanceFactor / roomArea);
+  const bulbsNeeded = Math.ceil(requiredLumens / (bulbLumens || 1));
+  const optimalBulbs = bulbsNeeded;
+  const optimalWatt = Math.ceil(requiredLumens / (optimalBulbs * (LUMENS_PER_WATT[i.bulbType] ?? 100)));
+  return {
+    roomArea, targetLux, requiredLumens, bulbLumens, currentLux,
+    bulbsNeeded, optimalBulbs, optimalWatt, utilizationFactor,
+  };
+}
+
+export function calculateLighting(i: LightingInput): LightingResult {
+  const c = computeLighting(i);
+  const luxRatio = getLuxRatio(c.currentLux, c.targetLux);
+  const status = getStatus(c.currentLux, c.targetLux);
+  return {
+    ...c,
+    status,
+    luxRatio,
+    sensoryContext: getSensoryContext(c.currentLux, c.targetLux),
+    suggestedProducts: getSuggestedProducts(c.optimalBulbs, i.bulbType, c.optimalWatt),
+  };
+}
+
+export function fmt0(n: number): string { return String(Math.round(n)); }
+export function fmt1(n: number): string { return n.toFixed(1); }

package/src/tool/lightingCalculator/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { lightingCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await lightingCalculator.i18n[locale]?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/lightingCalculator/state.ts

@@ -0,0 +1,113 @@
+import { calculateLighting } from './logic';
+import type { LightingInput, LightingResult } from './logic';
+
+const LS_KEY = 'lighting-calc';
+
+export interface State {
+  unitSys: 'metric' | 'imperial';
+  roomType: string;
+  bulbType: string;
+  luxMultiplier: number;
+}
+
+export const defaultState: State = {
+  unitSys: 'metric',
+  roomType: 'living',
+  bulbType: 'led',
+  luxMultiplier: 1,
+};
+
+export function loadState(): State {
+  const s = localStorage.getItem(LS_KEY);
+  if (!s) return { ...defaultState };
+  try {
+    const v = JSON.parse(s);
+    return {
+      unitSys: v.unit || defaultState.unitSys,
+      roomType: v.room || defaultState.roomType,
+      bulbType: v.bulb || defaultState.bulbType,
+      luxMultiplier: typeof v.ambient === 'number' ? v.ambient : defaultState.luxMultiplier,
+    };
+  } catch {
+    return { ...defaultState };
+  }
+}
+
+export function saveState(
+  st: State,
+  getNum: (id: string) => number,
+) {
+  const v = {
+    unit: st.unitSys,
+    room: st.roomType,
+    bulb: st.bulbType,
+    ambient: st.luxMultiplier,
+    w: getNum('lc-w'),
+    l: getNum('lc-l'),
+    h: getNum('lc-h'),
+    bw: getNum('lc-bw'),
+    f: getNum('lc-f'),
+  };
+  localStorage.setItem(LS_KEY, JSON.stringify(v));
+}
+
+export function restoreInputs(
+  getNum: (id: string) => number,
+  setVal: (id: string, v: string) => void,
+) {
+  const s = localStorage.getItem(LS_KEY);
+  if (!s) return;
+  try {
+    const v = JSON.parse(s);
+    const ids = ['lc-w', 'lc-l', 'lc-h', 'lc-bw', 'lc-f'];
+    const keys = ['w', 'l', 'h', 'bw', 'f'];
+    ids.forEach((id, i) => {
+      if (v[keys[i]] !== undefined) setVal(id, String(v[keys[i]]));
+    });
+  } catch {}
+}
+
+export function factors(unitSys: 'metric' | 'imperial') {
+  return unitSys === 'metric'
+    ? { rm: 1, hm: 1 }
+    : { rm: 0.3048, hm: 0.3048 };
+}
+
+export function runCalc(
+  st: State,
+  getNum: (id: string) => number,
+): LightingResult {
+  const f = factors(st.unitSys);
+  const input: LightingInput = {
+    roomWidthM: getNum('lc-w') * f.rm,
+    roomLengthM: getNum('lc-l') * f.rm,
+    roomHeightM: getNum('lc-h') * f.hm,
+    roomType: st.roomType,
+    bulbType: st.bulbType,
+    bulbWatt: getNum('lc-bw'),
+    fixtures: getNum('lc-f'),
+    luxMultiplier: st.luxMultiplier,
+  };
+  return calculateLighting(input);
+}
+
+export function updateUnitLabels(
+  unitSys: 'metric' | 'imperial',
+  setTxt: (id: string, v: string) => void,
+) {
+  const isM = unitSys === 'metric';
+  setTxt('lc-w-u', isM ? 'm' : 'ft');
+  setTxt('lc-l-u', isM ? 'm' : 'ft');
+  setTxt('lc-h-u', isM ? 'm' : 'ft');
+}
+
+export function convertValue(
+  id: string,
+  getNum: (id: string) => number,
+  setVal: (id: string, v: string) => void,
+  toMetric: boolean,
+) {
+  const factor = toMetric ? 0.3048 : 1 / 0.3048;
+  const v = getNum(id);
+  setVal(id, String(Math.round(v * factor * 10) / 10));
+}

package/src/tool/lightingCalculator/ui.ts

@@ -0,0 +1,48 @@
+export interface LightingCalculatorUI extends Record<string, string> {
+  sectionTitle: string;
+  labelRoomType: string;
+  labelRoomWidth: string;
+  labelRoomLength: string;
+  labelHeight: string;
+  labelBulbType: string;
+  labelBulbWatt: string;
+  labelFixtures: string;
+  labelAmbient: string;
+  btnAmbientCozy: string;
+  btnAmbientNormal: string;
+  btnAmbientBright: string;
+  unitMetricRoom: string;
+  unitImperialRoom: string;
+  unitHeight: string;
+  unitBulbs: string;
+  unitWatt: string;
+  unitLux: string;
+  labelTargetLux: string;
+  labelCurrentLux: string;
+  labelBulbsNeeded: string;
+  labelRoomArea: string;
+  statusOptimal: string;
+  statusInsufficient: string;
+  statusExcess: string;
+  btnLiving: string;
+  btnKitchen: string;
+  btnBedroom: string;
+  btnBathroom: string;
+  btnOffice: string;
+  btnHallway: string;
+  btnBulbLED: string;
+  btnBulbCFL: string;
+  btnBulbHalogen: string;
+  btnBulbIncandescent: string;
+  btnMetric: string;
+  btnImperial: string;
+  tipOptimal: string;
+  tipInsufficient: string;
+  tipExcess: string;
+  labelManualAdjust: string;
+  labelSummary: string;
+  labelTotalLumens: string;
+  labelSuggestedSetup: string;
+  btnExport: string;
+
+}

package/src/tools.ts

@@ -14,6 +14,7 @@ import { VAMPIRE_DRAW_SIMULATOR_TOOL } from './tool/vampireDrawSimulator/index';
 import { DESK_ERGONOMICS_TOOL } from './tool/deskErgonomics/index';
 import { APPLIANCE_COST_CALCULATOR_TOOL } from './tool/applianceCostCalculator/index';
 import { TILE_LAYOUT_CALCULATOR_TOOL } from './tool/tileLayoutCalculator/index';
+import { LIGHTING_CALCULATOR_TOOL } from './tool/lightingCalculator/index';
 
 export const ALL_TOOLS: ToolDefinition[] = [
   QR_GENERATOR_TOOL,
@@ -30,5 +31,6 @@ export const ALL_TOOLS: ToolDefinition[] = [
   DESK_ERGONOMICS_TOOL,
   APPLIANCE_COST_CALCULATOR_TOOL,
   TILE_LAYOUT_CALCULATOR_TOOL,
+  LIGHTING_CALCULATOR_TOOL,
 ];