@kizmann/pico-js 1.0.13 → 2.0.0

package/src/now/NowGrid.js

@@ -0,0 +1,251 @@
+import { Arr, Mix, Num, Obj, Str } from "#src/index.esm.js";
+
+/**
+ * @memberof PicoNow
+ * @extends {PicoNow}
+ */
+export class PicoNowGridInstance
+{
+    /**
+     * Get grid of dates by scope
+     *
+     * @example Now.grid("month") // => [Now, Now, ...]
+     *
+     * @param {string} [scope] Grid scope
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    grid(scope = 'day')
+    {
+        if ( /^seconds?$/i.test(scope) ) {
+            return this.getSecondsGrid();
+        }
+
+        if ( /^minutes?$/i.test(scope) ) {
+            return this.getMinutesGrid();
+        }
+
+        if ( /^hours?$/i.test(scope) ) {
+            return this.getHoursGrid();
+        }
+
+        if ( /^days?$/i.test(scope) ) {
+            return this.getDaysGrid();
+        }
+
+        if ( /^dates?$/i.test(scope) ) {
+            return this.getDatesGrid();
+        }
+
+        if ( /^months?$/i.test(scope) ) {
+            return this.getMonthsGrid();
+        }
+
+        if ( /^years?$/i.test(scope) ) {
+            return this.getYearsGrid();
+        }
+
+        if ( /^decades?$/i.test(scope) ) {
+            return this.getDecadesGrid();
+        }
+
+        throw new Error(`Invalid grid scope type "${scope}".`);
+    }
+
+    /**
+     * Get seconds grid
+     *
+     * @example Now.getSecondsGrid(10)
+     *
+     * @param {number} [interval] Step interval
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getSecondsGrid(interval = 1)
+    {
+        if ( interval == null ) {
+            interval = 1;
+        }
+
+        return Arr.make(60 / interval, (i) => {
+            return this.clone().second(i * interval);
+        });
+    }
+
+    /**
+     * Get minutes grid
+     *
+     * @example Now.getMinutesGrid(10)
+     *
+     * @param {number} [interval] Step interval
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getMinutesGrid(interval = 1)
+    {
+        if ( interval == null ) {
+            interval = 1;
+        }
+
+        return Arr.make(60 / interval, (i) => {
+            return this.clone().minute(i * interval);
+        });
+    }
+
+    /**
+     * Get hours grid
+     *
+     * @example Now.getHoursGrid(2)
+     *
+     * @param {number} [interval] Step interval
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getHoursGrid(interval = 1)
+    {
+        if ( interval == null ) {
+            interval = 1;
+        }
+
+        return Arr.make(24 / interval, (i) => {
+            return this.clone().hour(i * interval);
+        });
+    }
+
+    /**
+     * Get days grid
+     *
+     * @example Now.getDaysGrid()
+     *
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getDaysGrid()
+    {
+        let dates = [
+            this.first('date').first('day'), this.last('date').last('day')
+        ];
+
+        return dates[0].range(dates[1], 'date');
+    }
+
+    /**
+     * Get dates grid
+     *
+     * @example Now.getDatesGrid()
+     *
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getDatesGrid()
+    {
+        let dates = [
+            this.first('date'), this.last('date')
+        ];
+
+        return dates[0].range(dates[1], 'date');
+    }
+
+    /**
+     * Get months grid
+     *
+     * @example Now.getMonthsGrid()
+     *
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getMonthsGrid()
+    {
+        let dates = [
+            this.first('month'), this.last('month')
+        ];
+
+        return dates[0].range(dates[1], 'month');
+    }
+
+    /**
+     * Get years grid
+     *
+     * @example Now.getYearsGrid()
+     *
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getYearsGrid()
+    {
+        let dates = [
+            this.first('year'), this.clone().last('year')
+        ];
+
+        return dates[0].range(dates[1], 'year');
+    }
+
+    /**
+     * Get decades grid
+     *
+     * @example Now.getDecadesGrid()
+     *
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    getDecadesGrid()
+    {
+        let dates = [
+            this.first('decade'), this.clone().last('decade')
+        ];
+
+        return dates[0].range(dates[1], 'decade');
+    }
+
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getYears = function () {
+    console.warn('Now.getYears() is deprecated, use Now.grid(\'years\') instead.');
+    return this.grid('years');
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getMonths = function () {
+    console.warn('Now.getMonths() is deprecated, use Now.grid(\'months\') instead.');
+    return this.grid('months');
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getDates = function () {
+    console.warn('Now.getDates() is deprecated, use Now.grid(\'dates\') instead.');
+    return this.grid('dates');
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getHours = function () {
+    console.warn('Now.getHours() is deprecated, use Now.grid(\'hours\') instead.');
+    return this.grid('hours');
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getMinutes = function () {
+    console.warn('Now.getMinutes() is deprecated, use Now.grid(\'minutes\') instead.');
+    return this.grid('minutes');
+}
+
+/**
+ * @see PicoNow.grid
+ */
+PicoNowGridInstance.prototype.getSeconds = function () {
+    console.warn('Now.getSeconds() is deprecated, use Now.grid(\'seconds\') instead.');
+    return this.grid('seconds');
+}
+
+/**
+ * @returns {typeof import('#src/utils/Now.js').PicoNow}
+ */
+export const PicoNowGridPlugin = function (self) {
+
+    Obj.each(Mix.proto(PicoNowGridInstance), (fn, id) => {
+        self.prototype[id] = fn;
+    });
+
+    return self;
+}

package/src/now/NowHuman.js

@@ -0,0 +1,118 @@
+import { Arr, Locale, Mix, Num, Obj, Str } from "#src/index.esm.js";
+
+export const NOW_HUMAN_DAYS = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday'
+];
+
+export const NOW_HUMAN_MONTHS = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December'
+];
+
+/**
+ * @memberof PicoNow
+ * @extends {PicoNow}
+ */
+export class PicoNowHumanInstance
+{
+    /**
+     * Get human readable value
+     *
+     * @example Now.human("day") // => "Monday"
+     *
+     * @param {string} [scope] Value scope
+     * @param {number} [substr] Substring length
+     * @returns {string|number} Human value
+     */
+    human(scope = 'day', substr = null)
+    {
+        if ( /^days?$/i.test(scope) ) {
+            return this.getHumanDay(substr);
+        }
+
+        if ( /^months?$/i.test(scope) ) {
+            return this.getHumanMonth(substr);
+        }
+
+        return this.get(scope);
+    }
+
+    /**
+     * Get human readable day
+     *
+     * @example Now.getHumanDay(3) // => "Mon"
+     *
+     * @param {number} [substr] Substring length
+     * @returns {string} Day name
+     */
+    getHumanDay(substr = null)
+    {
+        let day = this.day() - 1;
+
+        if ( ! NOW_HUMAN_DAYS[day] ) {
+            throw new Error(`Invalid day number "${day}".`);
+        }
+
+        let value = Locale.trans(NOW_HUMAN_DAYS[day]);
+
+        if ( substr != null ) {
+            value = value.substring(0, substr);
+        }
+
+        return value;
+    }
+
+    /**
+     * Get human readable month
+     *
+     * @example Now.getHumanMonth(3) // => "Jan"
+     *
+     * @param {number} [substr] Substring length
+     * @returns {string} Month name
+     */
+    getHumanMonth(substr = null)
+    {
+        let month = this.day() - 1;
+
+        if ( ! NOW_HUMAN_MONTHS[month] ) {
+            throw new Error(`Invalid month number "${month}".`);
+        }
+
+        let value = Locale.trans(NOW_HUMAN_MONTHS[month]);
+
+        if ( substr != null ) {
+            value = value.substring(0, substr);
+        }
+
+        return value;
+    }
+
+}
+
+/**
+ * @returns {typeof import('#src/utils/Now.js').PicoNow}
+ */
+export const PicoNowHumanPlugin = function (self) {
+
+    Obj.each(Mix.proto(PicoNowHumanInstance), (fn, id) => {
+        self.prototype[id] = fn;
+    });
+
+    return self;
+}

package/src/now/NowMatch.js

@@ -0,0 +1,175 @@
+import { Mix, Now, Obj } from "#src/index.esm.js";
+
+/**
+ * @memberof PicoNow
+ * @extends {PicoNow}
+ */
+export class PicoNowMatchInstance
+{
+
+    /**
+     * Check if date is before value
+     *
+     * @example Now.make("2026-01-01").before("2026-02-12") // => true
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if before
+     */
+    before(value = null, format = 'x')
+    {
+        return this.code(format) < Now.make(value).code(format);
+    }
+
+    /**
+     * Check if date is before value date
+     *
+     * @example Now.make("2026-01-01").beforeDate("2026-02-12")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if before
+     */
+    beforeDate(value = null, format = 'YYYYMMDD')
+    {
+        return this.before(value, format);
+    }
+
+    /**
+     * Check if date is before value time
+     *
+     * @example Now.make("10:00:00").beforeTime("12:00:00")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if before
+     */
+    beforeTime(value = null, format = 'HHmmss')
+    {
+        return this.before(value, format);
+    }
+
+    /**
+     * Check if date is after value
+     *
+     * @example Now.make("2026-02-12").after("2026-01-01") // => true
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if after
+     */
+    after(value = null, format = 'x')
+    {
+        return this.code(format) > Now.make(value).code(format);
+    }
+
+    /**
+     * Check if date is after value date
+     *
+     * @example Now.make("2026-02-12").afterDate("2026-01-01")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if after
+     */
+    afterDate(value = null, format = 'YYYYMMDD')
+    {
+        return this.after(value, format);
+    }
+
+    /**
+     * Check if date is after value time
+     *
+     * @example Now.make("12:00:00").afterTime("10:00:00")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if after
+     */
+    afterTime(value = null, format = 'HHmmss')
+    {
+        return this.after(value, format);
+    }
+
+    /**
+     * Check if date equals value
+     *
+     * @example Now.make("2026-01-01").equal("2026-01-01") // => true
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if equal
+     */
+    equal(value = null, format = 'x')
+    {
+        if ( ! (value instanceof Now) ) {
+            value = Now.make(value);
+        }
+
+        return this.code(format) === value.clone().code(format);
+    }
+
+    /**
+     * Check if date equals value date
+     *
+     * @example Now.make("2026-01-01").equalDate("2026-01-01")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if equal
+     */
+    equalDate(value = null, format = 'YYYYMMDD')
+    {
+        return this.equal(value, format);
+    }
+
+    /**
+     * Check if date equals value time
+     *
+     * @example Now.make("12:00:00").equalTime("12:00:00")
+     *
+     * @param {any} [value] Compare value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if equal
+     */
+    equalTime(value = null, format = 'HHmmss')
+    {
+        return this.equal(value, format);
+    }
+
+    /**
+     * Check if date is between values
+     *
+     * @example Now.make("2026-01-15").between("2026-01-01", "2026-01-31")
+     *
+     * @param {any} [start] Start value
+     * @param {any} [end] End value
+     * @param {string} [format] Compare format
+     * @returns {boolean} True if between
+     */
+    between(start = null, end = null, format = 'YYYYMMDD')
+    {
+        let dates = [
+            Now.make(start), Now.make(end)
+        ];
+
+        if ( dates[0].after(dates[1], format) ) {
+            dates = dates.reverse();
+        }
+
+        return this.after(dates[0], format) && this.before(dates[1], format);
+    }
+
+}
+
+/**
+ * @returns {typeof import('#src/utils/Now.js').PicoNow}
+ */
+export const PicoNowMatchPlugin = function (self) {
+
+    Obj.each(Mix.proto(PicoNowMatchInstance), (fn, id) => {
+        self.prototype[id] = fn;
+    });
+
+    return self;
+}

package/src/now/NowRange.js

@@ -0,0 +1,70 @@
+import { Mix, Now, Obj, Arr } from "#src/index.esm.js";
+
+/**
+ * @memberof PicoNow
+ * @extends {PicoNow}
+ */
+export class PicoNowRangeInstance
+{
+
+    /**
+     * Get range of dates
+     *
+     * @example Now.range("2026-01-31", "day") // => [Now, Now, ...]
+     *
+     * @param {any} [value] End date
+     * @param {string} [scope] Range scope
+     * @returns {Array<PicoNow>} Array of dates
+     */
+    range(value = null, scope = 'date')
+    {
+        let format = 'YYYYMMDD';
+
+        if ( /^months?$/.test(scope) ) {
+            format = 'YYYYMM';
+        }
+
+        if ( /^years?$/.test(scope) ) {
+            format = 'YYYY';
+        }
+
+        let range = [];
+
+        let dates = [
+            this.clone(), Now.make(value)
+        ];
+
+        if ( dates[0].afterDate(dates[1]) ) {
+            dates = dates.reverse();
+        }
+
+        dates[1].add(1, scope);
+
+        for ( let day = dates[0]; ! day.equal(dates[1], format); day = day.next(scope) ) {
+            Arr.append(range, day);
+        }
+
+        return range;
+    }
+
+}
+
+/**
+ * @see PicoNow.range
+ */
+PicoNowRangeInstance.prototype.getDatesRange = function (...args) {
+    console.warn('NowRange.getDatesRange() is deprecated, use NowRange.range() instead.');
+    return this.range(...args);
+}
+
+/**
+ * @returns {typeof import('#src/utils/Now.js').PicoNow}
+ */
+export const PicoNowRangePlugin = function (self) {
+
+    Obj.each(Mix.proto(PicoNowRangeInstance), (fn, id) => {
+        self.prototype[id] = fn;
+    });
+
+    return self;
+}