@powfix/core-js 0.9.24 → 0.9.26

package/src/services/time/TimeService.ts

@@ -1,304 +0,0 @@
-import EventEmitter3 from 'eventemitter3';
-
-const LOG_TAG: string = 'TimeService';
-
-export enum TimeServiceStatus {
-  STOPPED = 0,
-  RUNNING = 1,
-}
-
-export enum TimeServiceEvent {
-  SYNCED = 'SYNCED',
-  SYNC_INTERVAL_CHANGED = 'SYNC_INTERVAL_CHANGED',
-}
-
-export class TimeService {
-  private static readonly DEFAULT_SYNC_INTERVAL: number = 60000;
-
-  protected status: TimeServiceStatus = TimeServiceStatus.STOPPED;
-  private offset?: TimeService.Offset | undefined;
-  private option: TimeService.Option;
-  private syncedAt?: TimeService.TimeStamp | undefined;
-
-  // Emitter
-  private emitter = new EventEmitter3();
-  public readonly on = this.emitter.on;
-  public readonly off = this.emitter.off;
-  private readonly emit = this.emitter.emit;
-
-  public static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset {
-    const {t1, t2, t3, t4} = ntpResult;
-    return ((t2 - t1) + (t3 - t4)) / 2;
-  }
-
-  constructor(option: TimeService.Option) {
-    this.option = option;
-
-    if (option.autoStart) {
-      this.start();
-    }
-
-    // Binding
-    this.start = this.start.bind(this);
-    this.stop = this.stop.bind(this);
-    this.sync = this.sync.bind(this);
-    this.getOption = this.getOption.bind(this);
-    this.setOption = this.setOption.bind(this);
-  }
-
-  public getOption(): TimeService.Option {
-    return this.option;
-  }
-
-  public setOption(option: TimeService.Option): TimeService.Option {
-    return this.option = option;
-  }
-
-  public getOffset(defaultValue: TimeService.Offset): TimeService.Offset;
-  public getOffset(): TimeService.Offset | undefined;
-  public getOffset(defaultValue?: TimeService.Offset): TimeService.Offset | undefined {
-    if (this.offset !== undefined) {
-      return this.offset;
-    }
-    if (defaultValue !== undefined) {
-      return defaultValue;
-    }
-    return undefined;
-  }
-
-  public setOffset(offset: TimeService.Offset): TimeService.Offset
-  public setOffset(offset: TimeService.Offset | undefined): TimeService.Offset
-  public setOffset(offset?: TimeService.Offset): TimeService.Offset | undefined {
-    return this.offset = offset;
-  }
-
-  public getSyncedAt(): TimeService.TimeStamp | undefined {
-    return this.syncedAt;
-  }
-
-  private setSyncedAt(syncedAt: TimeService.TimeStamp | undefined): TimeService.TimeStamp | undefined {
-    this.syncedAt = syncedAt;
-
-    // Emit
-    this.emit(TimeServiceEvent.SYNCED, syncedAt);
-
-    return syncedAt;
-  }
-
-  public getSyncInterval(): number | null {
-    if (this.option.syncInterval === undefined) {
-      // If option is undefined using default value
-      return TimeService.DEFAULT_SYNC_INTERVAL;
-    }
-
-    if (this.option.syncInterval === null || this.option.syncInterval === -1) {
-      // If option is null, do not sync automatically
-      return null;
-    }
-
-    return this.option.syncInterval;
-  }
-
-  public setSyncInterval(interval: TimeService.Option['syncInterval']) {
-    this.option.syncInterval = interval;
-
-    // Emit
-    this.emit(TimeServiceEvent.SYNC_INTERVAL_CHANGED, interval);
-
-    if (this.status === TimeServiceStatus.RUNNING) {
-      if (this.syncHandler !== undefined) {
-        this.stopSync();
-        this.startSync();
-      }
-    }
-  }
-
-  public getClientTime(defaultValue: TimeService.TimeStamp = Date.now()): TimeService.TimeStamp {
-    try {
-      if (typeof this.option.clientTimeProvider === 'function') {
-        return this.option.clientTimeProvider();
-      }
-    } catch (e) {
-      console.error(e);
-    }
-    return defaultValue;
-  }
-
-  public getServerTime(): TimeService.TimeStamp | null {
-    const offset = this.getOffset();
-    if (offset === undefined) {
-      return null;
-    }
-
-    const clientTime = this.getClientTime();
-    return clientTime + offset;
-  }
-
-  public getTime(): number {
-    return this.getServerTime() || this.getClientTime();
-  }
-
-  private readonly fetchServerNTPResult = async (t1: TimeService.NTPResult['t1']): Promise<TimeService.ServerNTPResult | null> => {
-    try {
-      if (typeof this.option.serverTimeProvider === 'function') {
-        return await this.option.serverTimeProvider(t1);
-      }
-    } catch (e) {
-      console.error(e);
-    }
-    return null;
-  }
-
-  public getStatus(): TimeServiceStatus {
-    return this.status;
-  }
-
-  public start() {
-    if (this.status !== TimeServiceStatus.STOPPED) {
-      console.warn(LOG_TAG, 'service is not stopped');
-      return;
-    }
-
-    // Change status
-    this.status = TimeServiceStatus.RUNNING;
-
-    // Sync immediately
-    this.sync().finally(() => {});
-
-    // Start sync
-    this.startSync();
-  }
-
-  public stop() {
-    if (this.status !== TimeServiceStatus.RUNNING) {
-      console.warn(LOG_TAG, 'service is not running');
-      return;
-    }
-
-    // Change status
-    this.status = TimeServiceStatus.RUNNING;
-
-    // Stop sync
-    this.stopSync();
-
-    // Reset offset
-    this.setOffset(undefined);
-
-    // Reset synced at
-    this.setSyncedAt(undefined);
-  }
-
-  public async sync(): Promise<TimeService.Offset | null> {
-    try {
-      // T1 (Client Request Time)
-      const requestedAt: number = Date.now();
-
-      // Fetch server time from server
-      const serverNtpResult = await this.fetchServerNTPResult(requestedAt);
-
-      // Check is null
-      if (serverNtpResult === null) {
-        console.warn(LOG_TAG, 'Failed to get server time');
-        return null;
-      }
-
-      // T2 (Server Receive Time)
-      const {t2} = serverNtpResult;
-
-      // Check is not a number
-      if (isNaN(Number(t2))) {
-        // Not a Number
-        console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
-        return null;
-      }
-
-      // T3 (Server Transmit Time)
-      const {t3} = serverNtpResult;
-
-      // Check is not a number
-      if (isNaN(Number(t3))) {
-        // Not a Number
-        console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
-        return null;
-      }
-
-      // T4 (Client Receive Time)
-      const receivedAt: number = Date.now();
-
-      const ntpResult: TimeService.NTPResult = {
-        t1: requestedAt,
-        t2: t2,
-        t3: t3,
-        t4: receivedAt,
-      };
-
-      // Calculate offset
-      const offset = TimeService.calculateNTPResultOffset(ntpResult);
-
-      // Save calculated offset
-      this.setOffset(offset);
-
-      // Mark synced timestamp
-      this.setSyncedAt(Date.now());
-    } catch (e) {
-      console.error(e);
-    }
-
-    return null;
-  }
-
-  private syncHandler?: ReturnType<typeof setInterval> | undefined;
-  private startSync() {
-    if (this.syncHandler !== undefined) {
-      console.warn('sync handler is not undefined', this.syncHandler);
-      return;
-    }
-
-    const syncInterval = this.getSyncInterval();
-    if (syncInterval === null) {
-      return;
-    }
-
-    this.syncHandler = setInterval(this.sync, syncInterval);
-  };
-
-  private stopSync() {
-    if (this.syncHandler === undefined) {
-      return;
-    }
-    clearInterval(this.syncHandler);
-    this.syncHandler = undefined;
-  };
-}
-
-export namespace TimeService {
-  export type Offset = number;
-  export type TimeStamp = number;
-
-  export interface NTPResult {
-    // T1 (Client Request Time)
-    t1: TimeStamp;
-
-    // T2 (Server Receive Time)
-    t2: TimeStamp;
-
-    // T3 (Server Transmit Time)
-    t3: TimeStamp;
-
-    // T4 (Client Receive Time)
-    t4: TimeStamp;
-  }
-
-  export interface ServerNTPResult extends Pick<NTPResult, 't2' | 't3'> {}
-
-  export type ClientTimeProvider = () => TimeStamp;
-  // export type ServerTimeProvider = ((t1: NTPResult['t1']) => ServerNTPResult) | ((t1: NTPResult['t1']) => Promise<ServerNTPResult>);
-  export type ServerTimeProvider = (t1: NTPResult['t1']) => (ServerNTPResult | null) | (Promise<ServerNTPResult | null>);
-
-  export interface Option {
-    autoStart?: boolean;
-    syncInterval?: number | null | undefined;                            // Sync interval in milliseconds
-    clientTimeProvider?: ClientTimeProvider | undefined;
-    serverTimeProvider?: ServerTimeProvider | undefined;
-  }
-}

package/src/services/time/index.ts

@@ -1 +0,0 @@
-export * from "./TimeService";

package/src/types/IntRage.ts

@@ -1,5 +0,0 @@
-type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
-  ? Acc[number]
-  : Enumerate<N, [...Acc, Acc['length']]>
-
-export type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>> | T;

package/src/utils/ArrayUtils.ts

@@ -1,25 +0,0 @@
-export class ArrayUtils {
-
-  /**
-   * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
-   * @param e 객체 배열
-   * @param key 값을 비교할 Property 키
-   */
-  static getGreatestObject(e: any[], key: string) {
-    return e.reduce((prev, current) => (
-      (prev[key] > current[key] ? prev : current)
-    ));
-  }
-
-  static removeDuplicate<T>(arr: T[]): T[] {
-    return [...new Set(arr)]
-  }
-
-  static removeObjectDuplicate(arr: any[], key: string) {
-    return arr.filter((v, i, self) => (
-      i === self.findIndex(e => (
-        e[key] === v[key]
-      ))
-    ))
-  }
-}

package/src/utils/BooleanUtils.ts

@@ -1,4 +0,0 @@
-export function parseBoolean(value: any, defaultValue: boolean): boolean {
-	if (value === undefined || value === null) return defaultValue;
-	return (value === 'true' || value === true) || (value === 1 || value === '1');
-}

package/src/utils/CoordinateUtils.ts

@@ -1,50 +0,0 @@
-import {Coordinate} from "../interfaces/Coordinate";
-
-export class CoordinateUtils {
-  public static isValidLatitude(latitude: Coordinate['latitude'] | string) {
-    return /^-?([0-8]?[0-9]|90)(\.[0-9]{1,15})$/.test(latitude.toString());
-  }
-
-  public static isValidLongitude(longitude: Coordinate['longitude'] | string) {
-    return /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,14})$/.test(longitude.toString());
-  }
-
-  public static isValidLatitudeLongitude(latitude: Coordinate['latitude'] | string, longitude: Coordinate['longitude'] | string) {
-    return CoordinateUtils.isValidLatitude(latitude) && CoordinateUtils.isValidLongitude(longitude);
-  }
-
-  public static isValidCoordinate(coordinate: Coordinate): boolean {
-    return this.isValidLatitudeLongitude(coordinate.latitude, coordinate.longitude);
-  }
-
-  public static crowDistance(...coordinates: Coordinate[]): number {
-    if (coordinates.length <= 2) {
-      const toRad = (value: number) => value * Math.PI / 180;
-
-      const c1 = coordinates[0];
-      const c2 = coordinates[1];
-      if (!c1 || !c2) {
-        return 0;
-      }
-
-      const R = 6371e3;
-      const dLat = toRad(c2.latitude - c1.latitude);
-      const dLon = toRad(c2.longitude - c1.longitude);
-      const lat1 = toRad(c1.latitude);
-      const lat2 = toRad(c2.latitude);
-
-      const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
-      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-
-      return R * c;
-    }
-
-    let totalDistance: number = 0;
-    for (let i = 0; i < coordinates.length - 1; ++i) {
-      totalDistance += this.crowDistance(coordinates[i], coordinates[i + 1]);
-    }
-
-    return totalDistance;
-  }
-}

package/src/utils/DateUtils.ts

@@ -1,213 +0,0 @@
-import moment, {Moment, MomentInput, RelativeTimeSpec} from "moment";
-
-export class DateUtils {
-  public static relativeDate = (input: MomentInput, from: MomentInput = Date.now()): string => {
-    // Create new moment instance to apply new locale
-    const datetime = moment.isMoment(input) ? moment(input.toDate()) : moment(input);
-
-    if (!datetime.isValid()) {
-      console.error('core-js:DateUtils.relativeDate() datetime is invalid', datetime);
-      return '<INVALID DATE>';
-    }
-
-    return datetime.from(from);
-  };
-
-  public static setLocale = (language: DateUtils.Locale) => {
-    const relativeTime = DateUtils.getRelativeTimeSpec(language);
-    if (relativeTime !== undefined) {
-      moment.updateLocale(language, {relativeTime});
-    }
-    moment.locale(language);
-  };
-
-  private static getRelativeTimeSpec = (locale: DateUtils.Locale): RelativeTimeSpec | undefined => {
-    if (locale in DateUtils.relativeTimeSpecs) {
-      return DateUtils.relativeTimeSpecs[locale];
-    }
-    return undefined;
-  };
-}
-
-export namespace DateUtils {
-  export type Locale = string;
-
-  export const relativeTimeSpecs: {[key: Locale]: RelativeTimeSpec} = {
-    ko: {
-      future: "%s 후",
-      past: "%s 전",
-      s: number => `${number}초`,
-      ss: number => `${number}초`,
-      m: number => `${number}분`,
-      mm: number => `${number}분`,
-      h: number => `${number}시간`,
-      hh: number => `${number}시간`,
-      d: number => `${number}일`,
-      dd: number => `${number}일`,
-      M: number => `${number}개월`,
-      MM: number => `${number}개월`,
-      y: number => `${number}년`,
-      yy: number => `${number}년`
-    } as RelativeTimeSpec,
-    en: {
-      future: "in %s",
-      past: "%s ago",
-      s: number => number === 1 ? `${number} second`: `${number} seconds`,
-      ss: number => `${number} seconds`,
-      m: number => number === 1 ? `${number} minute`: `${number} minutes`,
-      mm: number => `${number} minutes`,
-      h: number => number === 1 ? `${number} hour`: `${number} hours`,
-      hh: number => `${number} hours`,
-      d: number => number === 1 ? `${number} day`: `${number} days`,
-      dd: number => `${number} days`,
-      M: number => number === 1 ? `${number} month`: `${number} months`,
-      MM: number => `${number} months`,
-      y: number => number === 1 ? `${number} year`: `${number} years`,
-      yy: number => `${number} years`
-    } as RelativeTimeSpec,
-    ja: {
-      future: "%s後",
-      past: "%s前",
-      s: number => `${number}秒`,
-      ss: number => `${number}秒`,
-      m: number => `${number}分`,
-      mm: number => `${number}分`,
-      h: number => `${number}時`,
-      hh: number => `${number}時`,
-      d: number => `${number}日`,
-      dd: number => `${number}日`,
-      M: number => `${number}月`,
-      MM: number => `${number}月`,
-      y: number => `${number}年`,
-      yy: number => `${number}年`
-    } as RelativeTimeSpec,
-    zh: {
-      future: "%s后",
-      past: "%s前",
-      s: number => `${number}秒`,
-      ss: number => `${number}秒`,
-      m: number => `${number}分钟`,
-      mm: number => `${number}分钟`,
-      h: number => `${number}个小时`,
-      hh: number => `${number}个小时`,
-      d: number => `${number}天`,
-      dd: number => `${number}天`,
-      M: number => `${number}个月`,
-      MM: number => `${number}个月`,
-      y: number => `${number}年`,
-      yy: number => `${number}年`
-    } as RelativeTimeSpec,
-    ru: {
-      future: "через %s",
-      past: "%s назад",
-      s: number => `${number} секунд`,
-      ss: number => `${number} секунд`,
-      m: number => `${number} минута`,
-      mm: number => `${number} минут`,
-      h: number => `${number} час`,
-      hh: number => `${number} часов`,
-      d: number => `${number} день`,
-      dd: number => `${number} дней`,
-      M: number => `${number} месяц`,
-      MM: number => `${number} месяцев`,
-      y: number => `${number} год`,
-      yy: number => `${number} лет`
-    } as RelativeTimeSpec,
-    uz: {
-      future: "%sdan keyin",
-      past: "%s avval",
-      s: number => `${number} soniya`,
-      ss: number => `${number} soniya`,
-      m: number => `${number} daqiqa`,
-      mm: number => `${number} daqiqa`,
-      h: number => `${number} soat`,
-      hh: number => `${number} soat`,
-      d: number => `${number} kun`,
-      dd: number => `${number} kun`,
-      M: number => `${number} oy`,
-      MM: number => `${number} oy`,
-      y: number => `${number} yil`,
-      yy: number => `${number} yil`
-    } as RelativeTimeSpec,
-    de: {
-      future: "in %s",
-      past: "vor %s",
-      s: number => `${number === 1 ? "einer" : number} Sekunde${number === 1 ? "" : "n"}`,
-      ss: number => `${number} Sekunde${number === 1 ? "" : "n"}`,
-      m: number => `${number === 1 ? "einer" : number} Minute${number === 1 ? "" : "n"}`,
-      mm: number => `${number} Minute${number === 1 ? "" : "n"}`,
-      h: number => `${number === 1 ? "einer" : number} Stunde${number === 1 ? "" : "n"}`,
-      hh: number => `${number} Stunde${number === 1 ? "" : "n"}`,
-      d: number => `${number === 1 ? "einem" : number} Tag${number === 1 ? "" : "en"}`,
-      dd: number => `${number} Tag${number === 1 ? "" : "en"}`,
-      M: number => `${number === 1 ? "einem" : number} Monat${number === 1 ? "" : "en"}`,
-      MM: number => `${number} Monat${number === 1 ? "" : "en"}`,
-      y: number => `${number === 1 ? "einem" : number} Jahr${number === 1 ? "" : "en"}`,
-      yy: number => `${number} Jahr${number === 1 ? "" : "en"}`
-    } as RelativeTimeSpec,
-    fr: {
-      future: "dans %s",
-      past: "il y a %s",
-      s: number => `quelques secondes`,
-      ss: number => `${number} secondes`,
-      m: number => `une minute`,
-      mm: number => `${number} minutes`,
-      h: number => `une heure`,
-      hh: number => `${number} heures`,
-      d: number => `un jour`,
-      dd: number => `${number} jours`,
-      M: number => `un mois`,
-      MM: number => `${number} mois`,
-      y: number => `un an`,
-      yy: number => `${number} ans`
-    } as RelativeTimeSpec,
-    vi: {
-      future: "sau %s",
-      past: "%s trước",
-      s: number => `${number} giây`,
-      ss: number => `${number} giây`,
-      m: number => `${number} phút`,
-      mm: number => `${number} phút`,
-      h: number => `${number} giờ`,
-      hh: number => `${number} giờ`,
-      d: number => `${number} ngày`,
-      dd: number => `${number} ngày`,
-      M: number => `${number} tháng`,
-      MM: number => `${number} tháng`,
-      y: number => `${number} năm`,
-      yy: number => `${number} năm`
-    } as RelativeTimeSpec,
-    th: {
-      future: "ใน %s",
-      past: "%s ที่แล้ว",
-      s: number => `${number} วินาที`,
-      ss: number => `${number} วินาที`,
-      m: number => `${number} นาที`,
-      mm: number => `${number} นาที`,
-      h: number => `${number} ชั่วโมง`,
-      hh: number => `${number} ชั่วโมง`,
-      d: number => `${number} วัน`,
-      dd: number => `${number} วัน`,
-      M: number => `${number} เดือน`,
-      MM: number => `${number} เดือน`,
-      y: number => `${number} ปี`,
-      yy: number => `${number} ปี`
-    } as RelativeTimeSpec,
-    fil: {
-      future: "sa loob ng %s",
-      past: "%s ang nakalipas",
-      s: number => `${number} segundo`,
-      ss: number => `${number} segundo`,
-      m: number => `${number} minuto`,
-      mm: number => `${number} minuto`,
-      h: number => `${number} oras`,
-      hh: number => `${number} oras`,
-      d: number => `${number} araw`,
-      dd: number => `${number} araw`,
-      M: number => `${number} buwan`,
-      MM: number => `${number} buwan`,
-      y: number => `${number} taon`,
-      yy: number => `${number} taon`
-    } as RelativeTimeSpec,
-  };
-}

package/src/utils/JuminNumberUtils.ts

@@ -1,47 +0,0 @@
-import {between} from "./global/between";
-
-export class JuminNumberUtils {
-  public static calculateX(juminNumber: string): number {
-    const replacedJuminNumber = juminNumber.replace(/\D/g, '');
-    if (!between(replacedJuminNumber.length, 12, 13)) {
-      throw new Error('Jumin number length must be 12 to 13(without dash)');
-    }
-
-    const numbers = replacedJuminNumber.split('').map(e => parseInt(e, 10));
-    const sum = 2 * numbers[0] + 3 * numbers[1] + 4 * numbers[2] + 5 * numbers[3]
-      + 6 * numbers[4] + 7 * numbers[5] + 8 * numbers[6] + 9 * numbers[7]
-      + 2 * numbers[8] + 3 * numbers[9] + 4 * numbers[10] + 5 * numbers[11];
-    return (11 - (sum % 11)) % 10;
-  }
-
-  public static isValid(juminNumber: string): boolean {
-    const replacedJuminNumber = juminNumber.replace(/\D/g, '');
-    if (replacedJuminNumber.length !== 13) {
-      return false;
-    }
-
-    // 연도에 해당하는 숫자와 성별에 해당하는 숫자 비교
-    const TODAY_YEAR = parseInt(new Date().getFullYear().toString().slice(-2), 10);
-    const yearNum = parseInt(replacedJuminNumber.slice(0, 2), 10);
-    const sexNum = replacedJuminNumber.slice(6, 7); // 대시 있는경우 7로 변경
-    if (sexNum === '1' || sexNum === '2') {
-      if (yearNum < TODAY_YEAR) return false;
-    } else if (sexNum === '3' || sexNum === '4') {
-      if (yearNum > TODAY_YEAR) return false;
-    } else return false;
-
-    // 월과 일에 해당하는 숫자 조건 검사 (정규식으로)
-    const regex = /^\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{7}$/;
-    if (!regex.test(replacedJuminNumber)) return false;
-
-    // Validation X
-    const currentX = parseInt(replacedJuminNumber.slice(-1), 10);
-    const calculatedX = JuminNumberUtils.calculateX(replacedJuminNumber);
-    if (currentX !== calculatedX) {
-      console.log('Invalid X', currentX, calculatedX);
-      return false;
-    }
-
-    return true;
-  }
-}

package/src/utils/NumberUtils.ts

@@ -1,23 +0,0 @@
-export class NumberUtils {
-  public static formatWithThousandsSeparator(value: number, separator: string = ','): string {
-    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
-  }
-
-  public static formatBigNumber(value: number, precision: number = 2): string {
-    const map: {suffix: string, threshold: number}[] = [
-      {suffix: 'Qi', threshold: 1e18},
-      {suffix: 'Q', threshold: 1e15},
-      {suffix: 'T', threshold: 1e12},
-      {suffix: 'B', threshold: 1e9},
-      {suffix: 'M', threshold: 1e6},
-      {suffix: 'K', threshold: 1e3},
-      {suffix: '', threshold: 1},
-    ];
-
-    const found = map.find(e => Math.abs(value) >= e.threshold);
-    if (found) {
-      return Number((value / found.threshold).toFixed(precision)) + found.suffix;
-    }
-    return value.toString();
-  }
-}

package/src/utils/Point3Utils.ts

@@ -1,11 +0,0 @@
-import {Point3} from "../interfaces/Point3";
-
-export class Point3Utils {
-  static distance(p1: Point3, p2: Point3): number {
-    const dx = p1.x - p2.x;
-    const dy = p1.y - p2.y;
-    const dz = p1.z - p2.z;
-
-    return Math.sqrt( dx * dx + dy * dy + dz * dz );
-  }
-}