wenay-common2 1.0.1

package/lib/Common/Color.d.ts

@@ -0,0 +1,31 @@
+declare type Nominal<T, Name extends string> = T & {
+    [Symbol.species]: Name;
+};
+export type ColorNumber = Nominal<number, 'Color'>;
+export type ColorString = `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})` | `#${string}`;
+export type ColorRGB = Readonly<{
+    red: number;
+    green: number;
+    blue: number;
+}>;
+export type ColorRGBA = Readonly<{
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}>;
+export type ColorAny = ColorNumber | ColorString | Readonly<ColorRGBA>;
+export type Color = ColorString;
+export declare function rgb(red: number, green: number, blue: number): ColorString;
+export declare function colorGenerator(min?: number, max?: number): Generator<[number, number, number]>;
+export declare function colorGenerator2(data?: {
+    min?: number;
+    max?: number;
+}): Generator<[number, number, number]>;
+export declare function colorGeneratorByCount2(value?: number, count?: number, index?: number): [number, number, number];
+export declare function colorGeneratorByCount(value?: number, count?: number, index?: number): ColorString;
+export declare function colorStringToRGBA(str: ColorString): [number, number, number, number];
+export declare function colorStringToRGBA(str: string): [number, number, number, number] | undefined;
+export declare function toColorString(str: string): ColorString;
+export declare function isSimilarColors(color1: ColorString | readonly [number, number, number], color2: ColorString | readonly [number, number, number], maxDelta?: number): boolean;
+export {};

package/lib/Common/Color.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rgb = rgb;
+exports.colorGenerator = colorGenerator;
+exports.colorGenerator2 = colorGenerator2;
+exports.colorGeneratorByCount2 = colorGeneratorByCount2;
+exports.colorGeneratorByCount = colorGeneratorByCount;
+exports.colorStringToRGBA = colorStringToRGBA;
+exports.toColorString = toColorString;
+exports.isSimilarColors = isSimilarColors;
+function rgb(red, green, blue) { return `rgb(${red},${green},${blue})`; }
+function* colorGenerator(min = 0, max = 254) {
+    for (let step = Math.floor((max - min) / 2); step >= 1; step /= 2) {
+        let v = (max - min) / step;
+        for (let rStep = 0, r = 0; rStep <= v; rStep++, r += step)
+            for (let gStep = 0, g = 0; gStep <= v; gStep++, g += step)
+                for (let bStep = 0, b = 0; bStep <= v; bStep++, b += step) {
+                    if (r % (step * 2) == 0 && g % (step * 2) == 0 && b % (step * 2) == 0)
+                        continue;
+                    yield [Math.round(r) + min, Math.round(g) + min, Math.round(b) + min];
+                }
+    }
+    yield [-1, -1, -1];
+}
+function* colorGenerator2(data) {
+    const max = data?.max ?? 255;
+    const min = data?.min ?? 0;
+    function* _range(start = 0, end = 255) {
+        const range = (end - start) * 5;
+        for (let p = range; p > 1; p >>= 2) {
+            for (let i = 1, step = p >> 2; step * i < range; i++)
+                yield step * i;
+        }
+    }
+    const d = max - min;
+    let buf = [min, min, min];
+    const rangeGen = _range(min, max);
+    for (let num of rangeGen) {
+        buf = [min, min, min];
+        const p = Math.round(num / d);
+        const r = num % d;
+        if (p == 0) {
+            buf[0] = max;
+            buf[1] = min + r;
+        }
+        if (p == 1) {
+            buf[0] = max - r;
+            buf[1] = max;
+        }
+        if (p == 2) {
+            buf[1] = max;
+            buf[2] = min + r;
+        }
+        if (p == 3) {
+            buf[1] = max - r;
+            buf[2] = max;
+        }
+        if (p == 4) {
+            buf[2] = max;
+            buf[0] = min + r;
+        }
+        if (p == 5) {
+            buf[2] = max - r;
+            buf[0] = max;
+        }
+        yield buf;
+    }
+    yield [-1, -1, -1];
+}
+function colorGeneratorByCount2(value = 180, count = 100, index = 1) {
+    const step = Math.floor(value * 6 * index / count);
+    const p = Math.floor(step / value);
+    const z = Math.floor(step % value);
+    const r = (p == 0 || p == 5) ? value : (p == 1) ? value - z : (p == 4) ? z : 0;
+    const g = (p == 1 || p == 2) ? value : (p == 3) ? value - z : (p == 0) ? z : 0;
+    const b = (p == 3 || p == 4) ? value : (p == 5) ? value - z : (p == 2) ? z : 0;
+    return [r, g, b];
+}
+function colorGeneratorByCount(value = 180, count = 100, index = 1) {
+    const [r, g, b] = colorGeneratorByCount2(value, count, index);
+    return `rgb(${r},${g},${b})`;
+}
+function colorStringToRGBA(str) {
+    const rgbRegex = /^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
+    const rgbaRegex = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d*\.?\d+)\s*\)$/i;
+    let match = str.match(rgbRegex);
+    if (match) {
+        const [r, g, b] = match.slice(1).map(Number);
+        if (isValidRGBValue(r) && isValidRGBValue(g) && isValidRGBValue(b)) {
+            return [r, g, b, 1];
+        }
+    }
+    match = str.match(rgbaRegex);
+    if (match) {
+        const [r, g, b, a] = match.slice(1).map(Number);
+        if (isValidRGBValue(r) && isValidRGBValue(g) && isValidRGBValue(b) && isValidAlphaValue(a)) {
+            return [r, g, b, a];
+        }
+    }
+    return undefined;
+}
+function isValidRGBValue(value) {
+    return value >= 0 && value <= 255;
+}
+function isValidAlphaValue(value) {
+    return value >= 0 && value <= 1;
+}
+function toColorString(str) { if (colorStringToRGBA(str))
+    return str; throw `the string '${str}' is not valid 'rgb' or 'rgba' string`; }
+function isSimilarColors(color1, color2, maxDelta = 32) {
+    let [r1, g1, b1] = typeof color1 == "string" ? colorStringToRGBA(color1) : color1;
+    let [r2, g2, b2] = typeof color2 == "string" ? colorStringToRGBA(color2) : color2;
+    let delta = Math.abs(r1 - r2) + Math.abs(g1 - g2) + Math.abs(b1 - b2);
+    return delta <= maxDelta;
+}

package/lib/Common/Time.d.ts

@@ -0,0 +1,206 @@
+import { const_Date } from "./core/BaseTypes";
+export type DateString = `${number}-${number}-${number}`;
+export type TimeStringHHMM = `${number}:${number}`;
+export type TimeStringHHMMSS = `${number}:${number}:${number}`;
+export type TimeStringHHMMSS_ms = `${number}:${number}:${number}.${number}`;
+type TimeString_ = ` ${TimeStringHHMM | TimeStringHHMMSS | TimeStringHHMMSS_ms}`;
+export type DateTimeString = `${DateString}${TimeString_ | ""}${"Z" | ""}`;
+export { const_Date };
+export declare const H1_S = 3600;
+export declare const D1_S: number;
+export declare const W1_S: number;
+export declare const W1_MS: number;
+export declare const D1_MS: number;
+export declare const H1_MS: number;
+export declare const M1_MS: number;
+declare enum __E_TF {
+    S1 = 1,
+    S2 = 2,
+    S3 = 3,
+    S4 = 4,
+    S5 = 5,
+    S6 = 6,
+    S10 = 7,
+    S12 = 8,
+    S15 = 9,
+    S20 = 10,
+    S30 = 11,
+    M1 = 12,
+    M2 = 13,
+    M3 = 14,
+    M4 = 15,
+    M5 = 16,
+    M6 = 17,
+    M10 = 18,
+    M12 = 19,
+    M15 = 20,
+    M20 = 21,
+    M30 = 22,
+    H1 = 23,
+    H2 = 24,
+    H3 = 25,
+    H4 = 26,
+    H6 = 27,
+    H8 = 28,
+    H12 = 29,
+    D1 = 30,
+    W1 = 31,
+    MN1 = 32,
+    MN2 = 33,
+    MN3 = 34,
+    MN4 = 35,
+    MN6 = 36,
+    Y1 = 37
+}
+export interface IPeriod {
+    readonly msec: number;
+    readonly name: string;
+}
+type __E_TF_KEY = keyof typeof __E_TF;
+export declare class TIME_UNIT {
+    readonly index: number;
+    readonly msec: number;
+    readonly sec: number;
+    readonly name: string;
+    readonly sign: string;
+    private static _lastIndex;
+    private constructor();
+    static readonly MSecond: TIME_UNIT;
+    static readonly Second: TIME_UNIT;
+    static readonly Minute: TIME_UNIT;
+    static readonly Hour: TIME_UNIT;
+    static readonly Day: TIME_UNIT;
+    static readonly Week: TIME_UNIT;
+    static readonly Month: TIME_UNIT;
+    static readonly Year: TIME_UNIT;
+    readonly [key: number]: void;
+}
+declare type Nominal<T, Name extends string> = T & {
+    readonly [Symbol.species]: Name;
+};
+export type TFIndex = Nominal<number, 'TFIndex'>;
+export declare class TF implements IPeriod {
+    readonly sec: number;
+    readonly msec: number;
+    readonly name: string;
+    readonly unit: TIME_UNIT;
+    readonly unitCount: number;
+    readonly index: TFIndex;
+    readonly [key: number]: void;
+    valueOf(): number;
+    toString(): string;
+    private constructor();
+    private static constructFromSec;
+    static get<T extends string>(name: T): TF | (T extends __E_TF_KEY ? never : null);
+    static getAsserted(name: string): TF;
+    static fromName<T extends string>(name: T): TF | (T extends "D1" | "S1" | "S2" | "S3" | "S4" | "S5" | "S6" | "S10" | "S12" | "S15" | "S20" | "S30" | "M1" | "M2" | "M3" | "M4" | "M5" | "M6" | "M10" | "M12" | "M15" | "M20" | "M30" | "H1" | "H2" | "H3" | "H4" | "H6" | "H8" | "H12" | "W1" | "MN1" | "MN2" | "MN3" | "MN4" | "MN6" | "Y1" ? never : null);
+    static fromSec(value: number): TF | null;
+    static createCustomFromSec(sec: number): TF;
+    static createCustom(unit: TIME_UNIT, unitCount: number): TF;
+    static readonly all: readonly TF[];
+    private static readonly _mapBySec;
+    static readonly S1: TF;
+    static readonly S2: TF;
+    static readonly S3: TF;
+    static readonly S4: TF;
+    static readonly S5: TF;
+    static readonly S6: TF;
+    static readonly S10: TF;
+    static readonly S12: TF;
+    static readonly S15: TF;
+    static readonly S20: TF;
+    static readonly S30: TF;
+    static readonly M1: TF;
+    static readonly M2: TF;
+    static readonly M3: TF;
+    static readonly M4: TF;
+    static readonly M5: TF;
+    static readonly M6: TF;
+    static readonly M10: TF;
+    static readonly M12: TF;
+    static readonly M15: TF;
+    static readonly M20: TF;
+    static readonly M30: TF;
+    static readonly H1: TF;
+    static readonly H2: TF;
+    static readonly H3: TF;
+    static readonly H4: TF;
+    static readonly H6: TF;
+    static readonly H8: TF;
+    static readonly H12: TF;
+    static readonly D1: TF;
+    static readonly W1: TF;
+    static readonly MN1: TF;
+    static readonly MN2: TF;
+    static readonly MN3: TF;
+    static readonly MN4: TF;
+    static readonly MN6: TF;
+    static readonly Y1: TF;
+    static min(): never;
+    static min(...args: [TF, ...TF[]] | [[TF, ...TF[]]]): TF;
+    static min(...args: TF[] | [Iterable<TF>]): TF | null;
+    static max(): never;
+    static max(...args: [TF, ...TF[]] | [[TF, ...TF[]]]): TF;
+    static max(...args: TF[] | [Iterable<TF>]): TF | null;
+}
+declare class MyDate extends Date {
+    ToShiftedMsTime(shiftMs: number): Date;
+}
+export type MyDate_const = Omit<MyDate, keyof Date> & const_Date;
+export declare class PeriodSpan {
+    readonly period: Period;
+    readonly index: number;
+    readonly [key: number]: void;
+    constructor(period: Period | TF, indexOrTime: number | const_Date);
+    next(): PeriodSpan;
+    prev(): PeriodSpan;
+    get startTime(): MyDate;
+    get endTime(): Date;
+}
+export declare class Period implements IPeriod {
+    readonly tf: TF;
+    get sec(): number;
+    get msec(): number;
+    get name(): string;
+    valueOf(): number;
+    readonly [key: number]: PeriodSpan;
+    span(time: const_Date): PeriodSpan;
+    constructor(tf: TF);
+    static Seconds(tf: TF): number;
+    static Name(tf: TF): string;
+    IndexFromTime(time: const_Date): number;
+    getStartTime(currentTime: const_Date): MyDate;
+    private static getW1Shift_ms;
+    static W1Shift_ms: number;
+    static year0: number;
+    static IndexFromTime(tf: TF, time: const_Date): number;
+    static StartTimeForIndex(tf: TF, index: number): MyDate;
+    static StartTime(tf: TF, currentTime: const_Date, shiftPeriods?: number): MyDate;
+    static EndTime(tf: TF, currentTime: const_Date): Date;
+}
+export declare function timeToStr_hhmmss_ms(date: const_Date): string;
+export declare function timeToStr_hhmmss(date: const_Date): string;
+export declare function timeToStr_yyyymmdd_hhmm(date: const_Date, dateDelim?: string): string;
+export declare function timeToStr_yyyymmdd_hhmmss(date: const_Date, dateDelim?: string): string;
+export declare function timeToStr_yyyymmdd_hhmmss_ms(date: const_Date, dateDelim?: string): string;
+export declare function timeLocalToStr_hhmmss(date: const_Date): string;
+export declare function timeLocalToStr_hhmmss_ms(date: const_Date): string;
+export declare function timeLocalToStr_yyyymmdd(date: const_Date, dateDelim?: string): string;
+export declare function timeLocalToStr_yyyymmdd_hhmm(date: const_Date, dateDelim?: string): string;
+export declare function timeLocalToStr_yyyymmdd_hhmmss(date: const_Date, dateDelim?: string): string;
+export declare function timeLocalToStr_yyyymmdd_hhmmss_ms(date: const_Date, dateDelim?: string): string;
+export declare function timeToString_yyyymmdd_hhmm_offset(date: const_Date): string;
+export declare function timeToString_yyyymmdd_hhmmss_offset(date: const_Date): string;
+export declare function convertDatesToStrings(arg: any): any;
+export declare function toPrintObject(arg: any): any;
+export declare function durationToStr(duration_ms: number): string;
+export declare function durationToStrNullable(duration_ms: number | null | undefined): string | null;
+export declare function durationToStr_h_mm_ss(duration_ms: number): string;
+export declare function durationToStr_h_mm_ss_ms(duration_ms: number): string;
+export declare class CDelayer {
+    protected remainPause: number;
+    sleepAsync(pause_ms_getter: () => number | null): Promise<void>;
+}
+type NullableTime = const_Date | undefined | null;
+export declare function MinTime<T1 extends NullableTime, T2 extends NullableTime>(time1: T1, time2: T2): T1 | NonNullable<T2>;
+export declare function MaxTime<T1 extends NullableTime, T2 extends NullableTime>(time1: T1, time2: T2): T1 | NonNullable<T2>;