src/entities/temperature/model/useTemperatureStore.ts - dev - 45case/ptable

src/entities/temperature/model/useTemperatureStore.ts
353 строки9 KB
Olya
Страница Электроны + сайдбар с характеритстиками (Степень окисления, Конфигурация, Развёрнутая, Уровни энергии, ВЗМО)
24 июл 2026, 11:54
24 июл 2026, 11:543cf1d48
import { computed, ref } from "vue";

import { getElements } from "@/entities/element/api/elements";
import type {
  AbundanceKind,
  AtomicRadiusKind,
  ConductivityKind,
  DensityKind,
  HardnessKind,
  HeatKind,
  ModulusKind,
} from "@/entities/element/api/getElementProperties";

import {
  celsiusToKelvin,
  fahrenheitToKelvin,
  kelvinToCelsius,
  kelvinToFahrenheit,
} from "../lib/temperatureConverters";
import { updateElementStates } from "../lib/updateElementStates";
import type { ElementState } from "./elementState";
import {
  TEMPERATURE_MAX_K,
  TEMPERATURE_MIN_K,
  clampTemperatureK,
} from "./temperatureRange";

export type TemperatureUnit = "C" | "F" | "K";

/** Ptable Energy unit: affinity / ionization (kJ/mol default, eV optional). */
export type MolarEnergyUnit = "kJ" | "eV";

/** Ptable Density unit: kg/m³ (default) or g/cm³. */
export type DensityUnit = "kg" | "g";

export type {
  AbundanceKind,
  AtomicRadiusKind,
  ConductivityKind,
  DensityKind,
  HardnessKind,
  HeatKind,
  ModulusKind,
};

/** Ptable ionization order select (1st…30th). */
export const IONIZATION_ORDER_MIN = 1;
export const IONIZATION_ORDER_MAX = 30;

/** Ptable Discovered year slider bounds (CE / н. э.). */
export const DISCOVERY_YEAR_MIN = 1730;
export const DISCOVERY_YEAR_MAX = 2024;

const ATOMIC_RADIUS_KINDS: readonly AtomicRadiusKind[] = [
  "calculated",
  "empirical",
  "covalent",
  "vanderwaals",
];

const HARDNESS_KINDS: readonly HardnessKind[] = ["brinell", "mohs", "vickers"];

const MODULUS_KINDS: readonly ModulusKind[] = ["bulk", "shear", "young"];

const DENSITY_KINDS: readonly DensityKind[] = ["stp", "liquid"];

const CONDUCTIVITY_KINDS: readonly ConductivityKind[] = ["thermal", "electric"];

const HEAT_KINDS: readonly HeatKind[] = ["specific", "vaporization", "fusion"];

const ABUNDANCE_KINDS: readonly AbundanceKind[] = [
  "universe",
  "solar",
  "meteor",
  "crust",
  "ocean",
  "human",
];

export const minTemperatureK = TEMPERATURE_MIN_K;
export const maxTemperatureK = TEMPERATURE_MAX_K;
export const TEMPERATURE_STATE_PREVIEW_MS = 500;

const baseElements = getElements();
const currentTemperatureK = ref(celsiusToKelvin(0));
const temperatureUnit = ref<TemperatureUnit>("C");
const molarEnergyUnit = ref<MolarEnergyUnit>("kJ");
const ionizationOrder = ref(IONIZATION_ORDER_MIN);
const atomicRadiusKind = ref<AtomicRadiusKind>("calculated");
const hardnessKind = ref<HardnessKind>("brinell");
const modulusKind = ref<ModulusKind>("bulk");
const densityKind = ref<DensityKind>("stp");
const densityUnit = ref<DensityUnit>("kg");
const conductivityKind = ref<ConductivityKind>("thermal");
const heatKind = ref<HeatKind>("specific");
const abundanceKind = ref<AbundanceKind>("universe");
/** Ptable Discovered year slider (CE), default = max so all elements are shown. */
const discoveryYear = ref(DISCOVERY_YEAR_MAX);
const isStatePreviewActive = ref(false);

let statePreviewTimer: ReturnType<typeof setTimeout> | null = null;

function triggerStatePreview() {
  isStatePreviewActive.value = true;

  if (statePreviewTimer !== null) {
    clearTimeout(statePreviewTimer);
  }

  statePreviewTimer = setTimeout(() => {
    isStatePreviewActive.value = false;
    statePreviewTimer = null;
  }, TEMPERATURE_STATE_PREVIEW_MS);
}

function kelvinToUnit(kelvin: number, unit: TemperatureUnit): number {
  if (unit === "C") {
    return kelvinToCelsius(kelvin);
  }
  if (unit === "F") {
    return kelvinToFahrenheit(kelvin);
  }
  return kelvin;
}

function unitToKelvin(value: number, unit: TemperatureUnit): number {
  if (unit === "C") {
    return celsiusToKelvin(value);
  }
  if (unit === "F") {
    return fahrenheitToKelvin(value);
  }
  return value;
}

/** Display limits from rounded °C scale: -273…5727°C → -459…10341°F, 0…6000 K. */
function displayLimitKelvin(kelvin: number, unit: TemperatureUnit): number {
  if (unit === "K") {
    return kelvin;
  }

  const celsius = Math.round(kelvinToCelsius(kelvin));
  if (unit === "C") {
    return celsius;
  }

  return Math.round((celsius * 9) / 5 + 32);
}

export function useTemperatureStore() {
  const temperatureCelsius = computed(() => kelvinToCelsius(currentTemperatureK.value));
  const temperatureFahrenheit = computed(() => kelvinToFahrenheit(currentTemperatureK.value));

  const temperatureInSelectedUnit = computed(() => {
    if (temperatureUnit.value === "F") {
      const celsius = Math.round(kelvinToCelsius(currentTemperatureK.value));
      const minCelsius = Math.round(kelvinToCelsius(TEMPERATURE_MIN_K));
      const maxCelsius = Math.round(kelvinToCelsius(TEMPERATURE_MAX_K));

      if (celsius >= maxCelsius) {
        return (maxCelsius * 9) / 5 + 32;
      }
      if (celsius <= minCelsius) {
        return (minCelsius * 9) / 5 + 32;
      }

      return kelvinToFahrenheit(currentTemperatureK.value);
    }

    return kelvinToUnit(currentTemperatureK.value, temperatureUnit.value);
  });

  const minTemperatureInSelectedUnit = computed(() =>
    displayLimitKelvin(TEMPERATURE_MIN_K, temperatureUnit.value),
  );

  const maxTemperatureInSelectedUnit = computed(() =>
    displayLimitKelvin(TEMPERATURE_MAX_K, temperatureUnit.value),
  );

  const elementsWithState = computed(() =>
    updateElementStates(baseElements, currentTemperatureK.value),
  );

  const elementStates = computed(() => {
    const states = new Map<number, ElementState>();
    const elements = elementsWithState.value;

    for (let index = 0; index < elements.length; index += 1) {
      const element = elements[index]!;
      states.set(element.atomicNumber, element.state);
    }

    return states;
  });

  function setCurrentTemperatureK(temperatureK: number) {
    const nextTemperatureK = clampTemperatureK(temperatureK);

    if (nextTemperatureK === currentTemperatureK.value) {
      return;
    }

    currentTemperatureK.value = nextTemperatureK;
    triggerStatePreview();
  }

  function setTemperatureFromCelsius(celsius: number) {
    setCurrentTemperatureK(celsiusToKelvin(celsius));
  }

  function setTemperatureFromFahrenheit(fahrenheit: number) {
    setCurrentTemperatureK(fahrenheitToKelvin(fahrenheit));
  }

  function setTemperatureFromSelectedUnit(value: number) {
    setCurrentTemperatureK(unitToKelvin(value, temperatureUnit.value));
  }

  function setTemperatureUnit(unit: TemperatureUnit) {
    temperatureUnit.value = unit;
  }

  function setMolarEnergyUnit(unit: MolarEnergyUnit) {
    if (unit === "kJ" || unit === "eV") {
      molarEnergyUnit.value = unit;
    }
  }

  function setIonizationOrder(order: number) {
    if (
      Number.isInteger(order) &&
      order >= IONIZATION_ORDER_MIN &&
      order <= IONIZATION_ORDER_MAX
    ) {
      ionizationOrder.value = order;
    }
  }

  function setAtomicRadiusKind(kind: AtomicRadiusKind) {
    if (ATOMIC_RADIUS_KINDS.includes(kind)) {
      atomicRadiusKind.value = kind;
    }
  }

  function setHardnessKind(kind: HardnessKind) {
    if (HARDNESS_KINDS.includes(kind)) {
      hardnessKind.value = kind;
    }
  }

  function setModulusKind(kind: ModulusKind) {
    if (MODULUS_KINDS.includes(kind)) {
      modulusKind.value = kind;
    }
  }

  function setDensityKind(kind: DensityKind) {
    if (DENSITY_KINDS.includes(kind)) {
      densityKind.value = kind;
    }
  }

  function setDensityUnit(unit: DensityUnit) {
    if (unit === "kg" || unit === "g") {
      densityUnit.value = unit;
    }
  }

  function setConductivityKind(kind: ConductivityKind) {
    if (CONDUCTIVITY_KINDS.includes(kind)) {
      conductivityKind.value = kind;
    }
  }

  function setHeatKind(kind: HeatKind) {
    if (HEAT_KINDS.includes(kind)) {
      heatKind.value = kind;
    }
  }

  function setAbundanceKind(kind: AbundanceKind) {
    if (ABUNDANCE_KINDS.includes(kind)) {
      abundanceKind.value = kind;
    }
  }

  function setDiscoveryYear(year: number) {
    if (!Number.isFinite(year)) {
      return;
    }
    discoveryYear.value = Math.min(
      DISCOVERY_YEAR_MAX,
      Math.max(DISCOVERY_YEAR_MIN, Math.round(year)),
    );
  }

  function stepDiscoveryYear(delta: number) {
    setDiscoveryYear(discoveryYear.value + delta);
  }

  function getElementStateByAtomicNumber(atomicNumber: number): ElementState {
    return elementStates.value.get(atomicNumber) ?? "unknown";
  }

  return {
    abundanceKind,
    atomicRadiusKind,
    celsiusToKelvin,
    conductivityKind,
    currentTemperatureK,
    densityKind,
    densityUnit,
    discoveryYear,
    elementStates,
    elementsWithState,
    hardnessKind,
    heatKind,
    isStatePreviewActive,
    fahrenheitToKelvin,
    getElementStateByAtomicNumber,
    ionizationOrder,
    kelvinToCelsius,
    kelvinToFahrenheit,
    maxTemperatureInSelectedUnit,
    maxTemperatureK,
    minTemperatureInSelectedUnit,
    minTemperatureK,
    modulusKind,
    molarEnergyUnit,
    setAbundanceKind,
    setAtomicRadiusKind,
    setConductivityKind,
    setCurrentTemperatureK,
    setDensityKind,
    setDensityUnit,
    setDiscoveryYear,
    setHardnessKind,
    setHeatKind,
    setIonizationOrder,
    setModulusKind,
    setMolarEnergyUnit,
    setTemperatureFromCelsius,
    setTemperatureFromFahrenheit,
    setTemperatureFromSelectedUnit,
    setTemperatureUnit,
    stepDiscoveryYear,
    temperatureCelsius,
    temperatureFahrenheit,
    temperatureInSelectedUnit,
    temperatureUnit,
  };
}