@powfix/core-js 0.30.1 → 0.31.0

package/dist/browser/utils/SortUtils.cjs

@@ -93,7 +93,7 @@ var SortUtils = /*#__PURE__*/ function(_shared_SortUtils) {
         {
             key: "toGridSortModel",
             value: function toGridSortModel(items) {
-                return items.map(this.toGridSortItem);
+                return items.map(SortUtils.toGridSortItem);
             }
         },
         {
@@ -108,7 +108,7 @@ var SortUtils = /*#__PURE__*/ function(_shared_SortUtils) {
         {
             key: "fromGridSortModel",
             value: function fromGridSortModel(model) {
-                return model.map(this.fromGridSortItem);
+                return model.map(SortUtils.fromGridSortItem);
             }
         }
     ]);

package/dist/browser/utils/SortUtils.js

@@ -93,7 +93,7 @@ var SortUtils = /*#__PURE__*/ function(SortUtils$1) {
         {
             key: "toGridSortModel",
             value: function toGridSortModel(items) {
-                return items.map(this.toGridSortItem);
+                return items.map(SortUtils.toGridSortItem);
             }
         },
         {
@@ -108,7 +108,7 @@ var SortUtils = /*#__PURE__*/ function(SortUtils$1) {
         {
             key: "fromGridSortModel",
             value: function fromGridSortModel(model) {
-                return model.map(this.fromGridSortItem);
+                return model.map(SortUtils.fromGridSortItem);
             }
         }
     ]);

package/dist/shared/utils/TimeSeriesBucketUtils.cjs

@@ -0,0 +1,430 @@
+'use strict';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var chunkQHUNR4O5_cjs = require('../../chunk-QHUNR4O5.cjs');
+var _TimeSeriesBucketUtils = /*#__PURE__*/ function() {
+    function _TimeSeriesBucketUtils() {
+        _class_call_check(this, _TimeSeriesBucketUtils);
+    }
+    _create_class(_TimeSeriesBucketUtils, null, [
+        {
+            key: "fillMissingUtcBuckets",
+            value: /**
+   * 시계열 데이터에서 누락된 UTC bucket row를 채운다.
+   *
+   * 특징:
+   * - 모든 bucket 계산은 UTC 기준으로 처리한다.
+   * - 출력 dateKey 값은 항상 ISO 문자열이다.
+   * - dateRange가 없으면 rows 내 가장 과거/미래 bucket을 사용한다.
+   * - dateRange 양쪽 값이 모두 있으면 순서와 무관하게 더 과거 값이 start가 된다.
+   * - 동일 bucket으로 정규화되는 row가 2개 이상이면 throw 한다.
+   *
+   * 주의:
+   * - number date input은 JavaScript Date 생성자와 동일하게 millisecond timestamp로 처리된다.
+   * - string date input의 파싱은 new Date(value)에 위임한다.
+   */ function fillMissingUtcBuckets(rows, options) {
+                if (!Array.isArray(rows)) {
+                    throw new TypeError("rows must be an array.");
+                }
+                if (!_TimeSeriesBucketUtils.isRecord(options)) {
+                    throw new TypeError("options must be an object.");
+                }
+                var dateKey = options.dateKey, unit = options.unit, fillValues = options.fillValues, dateRange = options.dateRange;
+                if (typeof dateKey !== "string" || dateKey.length === 0) {
+                    throw new TypeError("dateKey must be a non-empty string.");
+                }
+                _TimeSeriesBucketUtils.assertDateBucketUnit(unit);
+                if (dateRange !== void 0) {
+                    _TimeSeriesBucketUtils.assertDateRange(dateRange);
+                }
+                if (fillValues !== void 0 && typeof fillValues !== "function" && !_TimeSeriesBucketUtils.isRecord(fillValues)) {
+                    throw new TypeError("fillValues must be an object or a function.");
+                }
+                var normalizedRows = [];
+                var minBucketTime;
+                var maxBucketTime;
+                for(var index = 0; index < rows.length; index += 1){
+                    var row = rows[index];
+                    if (!_TimeSeriesBucketUtils.isRecord(row)) {
+                        throw new TypeError("rows[".concat(index, "] must be an object."));
+                    }
+                    if (!(dateKey in row)) {
+                        throw new Error("rows[".concat(index, '] does not have dateKey "').concat(dateKey, '".'));
+                    }
+                    var rawDate = row[dateKey];
+                    var bucketDate = _TimeSeriesBucketUtils.startOfUtcBucket(rawDate, unit, "rows[".concat(index, "].").concat(dateKey));
+                    var bucketTime = bucketDate.getTime();
+                    var isoDate = bucketDate.toISOString();
+                    normalizedRows.push({
+                        row: row,
+                        isoDate: isoDate,
+                        bucketTime: bucketTime
+                    });
+                    minBucketTime = minBucketTime === void 0 ? bucketTime : Math.min(minBucketTime, bucketTime);
+                    maxBucketTime = maxBucketTime === void 0 ? bucketTime : Math.max(maxBucketTime, bucketTime);
+                }
+                var resolvedRange = _TimeSeriesBucketUtils.resolveUtcBucketRange(minBucketTime, maxBucketTime, unit, dateRange);
+                if (resolvedRange === null) {
+                    return [];
+                }
+                var rangeStart = resolvedRange.start, rangeEnd = resolvedRange.end;
+                if (rangeStart.getTime() > rangeEnd.getTime()) {
+                    throw new Error("Resolved dateRange start must be less than or equal to resolved dateRange end.");
+                }
+                var rangeStartTime = rangeStart.getTime();
+                var rangeEndTime = rangeEnd.getTime();
+                var bucketMap = /* @__PURE__ */ new Map();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = normalizedRows[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var normalizedRow = _step.value;
+                        if (normalizedRow.bucketTime < rangeStartTime || normalizedRow.bucketTime > rangeEndTime) {
+                            continue;
+                        }
+                        if (bucketMap.has(normalizedRow.isoDate)) {
+                            throw new Error('Duplicate UTC bucket detected for "'.concat(dateKey, '": ').concat(normalizedRow.isoDate, ". Pre-aggregate or de-duplicate rows before calling fillMissingUtcBuckets."));
+                        }
+                        bucketMap.set(normalizedRow.isoDate, _object_spread_props(_object_spread({}, normalizedRow.row), _define_property({}, dateKey, normalizedRow.isoDate)));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                var result = [];
+                var resolvedFillValues = fillValues === void 0 ? {} : fillValues;
+                var cursor = rangeStart;
+                while(cursor.getTime() <= rangeEndTime){
+                    var isoDate1 = cursor.toISOString();
+                    var existingRow = bucketMap.get(isoDate1);
+                    if (existingRow) {
+                        result.push(existingRow);
+                    } else {
+                        var valuesToFill = typeof resolvedFillValues === "function" ? resolvedFillValues({
+                            isoDate: isoDate1,
+                            date: new Date(cursor.getTime()),
+                            unit: unit
+                        }) : resolvedFillValues;
+                        if (!_TimeSeriesBucketUtils.isRecord(valuesToFill)) {
+                            throw new TypeError("fillValues function must return an object.");
+                        }
+                        result.push(_object_spread_props(_object_spread({}, valuesToFill), _define_property({}, dateKey, isoDate1)));
+                    }
+                    cursor = _TimeSeriesBucketUtils.addUtcBucketUnit(cursor, unit);
+                }
+                return result;
+            }
+        },
+        {
+            key: "resolveUtcBucketRange",
+            value: function resolveUtcBucketRange(minBucketTime, maxBucketTime, unit, dateRange) {
+                var hasRows = minBucketTime !== void 0 && maxBucketTime !== void 0;
+                if (dateRange === void 0) {
+                    if (!hasRows) {
+                        return null;
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                var _dateRange = _sliced_to_array(dateRange, 2), left = _dateRange[0], right = _dateRange[1];
+                var hasLeft = left !== null && left !== void 0;
+                var hasRight = right !== null && right !== void 0;
+                if (!hasLeft && !hasRight) {
+                    if (!hasRows) {
+                        return null;
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                if (hasLeft && hasRight) {
+                    var leftBucket = _TimeSeriesBucketUtils.startOfUtcBucket(left, unit, "dateRange[0]");
+                    var rightBucket = _TimeSeriesBucketUtils.startOfUtcBucket(right, unit, "dateRange[1]");
+                    if (leftBucket.getTime() <= rightBucket.getTime()) {
+                        return {
+                            start: leftBucket,
+                            end: rightBucket
+                        };
+                    }
+                    return {
+                        start: rightBucket,
+                        end: leftBucket
+                    };
+                }
+                if (hasLeft) {
+                    if (!hasRows) {
+                        throw new Error("dateRange[1] is nullish, so rows are required to infer dateRange end.");
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(left, unit, "dateRange[0]"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                if (!hasRows) {
+                    throw new Error("dateRange[0] is nullish, so rows are required to infer dateRange start.");
+                }
+                return {
+                    start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                    end: _TimeSeriesBucketUtils.startOfUtcBucket(right, unit, "dateRange[1]")
+                };
+            }
+        },
+        {
+            key: "startOfUtcBucket",
+            value: function startOfUtcBucket(value, unit, argumentName) {
+                var date = _TimeSeriesBucketUtils.toDate(value, argumentName);
+                var year = date.getUTCFullYear();
+                var month = date.getUTCMonth();
+                var day = date.getUTCDate();
+                var hour = date.getUTCHours();
+                var minute = date.getUTCMinutes();
+                var second = date.getUTCSeconds();
+                switch(unit){
+                    case "year":
+                        return new Date(Date.UTC(year, 0, 1, 0, 0, 0, 0));
+                    case "quarter":
+                        {
+                            var quarterStartMonth = Math.floor(month / 3) * 3;
+                            return new Date(Date.UTC(year, quarterStartMonth, 1, 0, 0, 0, 0));
+                        }
+                    case "month":
+                        return new Date(Date.UTC(year, month, 1, 0, 0, 0, 0));
+                    case "week":
+                        {
+                            var dayOfWeek = new Date(Date.UTC(year, month, day)).getUTCDay();
+                            var daysSinceMonday = (dayOfWeek + 6) % 7;
+                            return new Date(Date.UTC(year, month, day - daysSinceMonday, 0, 0, 0, 0));
+                        }
+                    case "day":
+                        return new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+                    case "hour":
+                        return new Date(Date.UTC(year, month, day, hour, 0, 0, 0));
+                    case "minute":
+                        return new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+                    case "second":
+                        return new Date(Date.UTC(year, month, day, hour, minute, second, 0));
+                }
+            }
+        },
+        {
+            key: "addUtcBucketUnit",
+            value: function addUtcBucketUnit(date, unit) {
+                var next = new Date(date.getTime());
+                switch(unit){
+                    case "year":
+                        next.setUTCFullYear(next.getUTCFullYear() + 1);
+                        break;
+                    case "quarter":
+                        next.setUTCMonth(next.getUTCMonth() + 3);
+                        break;
+                    case "month":
+                        next.setUTCMonth(next.getUTCMonth() + 1);
+                        break;
+                    case "week":
+                        next.setUTCDate(next.getUTCDate() + 7);
+                        break;
+                    case "day":
+                        next.setUTCDate(next.getUTCDate() + 1);
+                        break;
+                    case "hour":
+                        next.setUTCHours(next.getUTCHours() + 1);
+                        break;
+                    case "minute":
+                        next.setUTCMinutes(next.getUTCMinutes() + 1);
+                        break;
+                    case "second":
+                        next.setUTCSeconds(next.getUTCSeconds() + 1);
+                        break;
+                }
+                return _TimeSeriesBucketUtils.startOfUtcBucket(next, unit, "date");
+            }
+        },
+        {
+            key: "toDate",
+            value: function toDate(value, argumentName) {
+                var isSupportedDateInput = typeof value === "string" || typeof value === "number" || _instanceof(value, Date);
+                if (!isSupportedDateInput) {
+                    throw new TypeError("".concat(argumentName, " must be a string, number timestamp, or Date instance."));
+                }
+                var date = _instanceof(value, Date) ? new Date(value.getTime()) : new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error("".concat(argumentName, " must be a valid date value."));
+                }
+                return date;
+            }
+        },
+        {
+            key: "assertDateBucketUnit",
+            value: function assertDateBucketUnit(unit) {
+                if (!_TimeSeriesBucketUtils.DATE_BUCKET_UNITS.includes(unit)) {
+                    throw new TypeError("unit must be one of: ".concat(_TimeSeriesBucketUtils.DATE_BUCKET_UNITS.join(", "), "."));
+                }
+            }
+        },
+        {
+            key: "assertDateRange",
+            value: function assertDateRange(dateRange) {
+                if (!Array.isArray(dateRange) || dateRange.length !== 2) {
+                    throw new TypeError("dateRange must be a tuple with exactly two items.");
+                }
+            }
+        },
+        {
+            key: "isRecord",
+            value: function isRecord(value) {
+                return (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null && !Array.isArray(value);
+            }
+        }
+    ]);
+    return _TimeSeriesBucketUtils;
+}();
+chunkQHUNR4O5_cjs.__publicField(_TimeSeriesBucketUtils, "DATE_BUCKET_UNITS", [
+    "year",
+    "quarter",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second"
+]);
+var TimeSeriesBucketUtils = _TimeSeriesBucketUtils;
+exports.TimeSeriesBucketUtils = TimeSeriesBucketUtils;

package/dist/shared/utils/TimeSeriesBucketUtils.d.ts

@@ -0,0 +1,26 @@
+import { FilledUtcBucketRow, FillMissingUtcBucketsOptions } from "./TimeSeriesBucketUtils.types.js";
+export declare class TimeSeriesBucketUtils {
+    private static readonly DATE_BUCKET_UNITS;
+    /**
+     * 시계열 데이터에서 누락된 UTC bucket row를 채운다.
+     *
+     * 특징:
+     * - 모든 bucket 계산은 UTC 기준으로 처리한다.
+     * - 출력 dateKey 값은 항상 ISO 문자열이다.
+     * - dateRange가 없으면 rows 내 가장 과거/미래 bucket을 사용한다.
+     * - dateRange 양쪽 값이 모두 있으면 순서와 무관하게 더 과거 값이 start가 된다.
+     * - 동일 bucket으로 정규화되는 row가 2개 이상이면 throw 한다.
+     *
+     * 주의:
+     * - number date input은 JavaScript Date 생성자와 동일하게 millisecond timestamp로 처리된다.
+     * - string date input의 파싱은 new Date(value)에 위임한다.
+     */
+    static fillMissingUtcBuckets<T extends object, K extends Extract<keyof T, string>>(rows: readonly T[], options: FillMissingUtcBucketsOptions<T, K>): FilledUtcBucketRow<T, K>[];
+    private static resolveUtcBucketRange;
+    private static startOfUtcBucket;
+    private static addUtcBucketUnit;
+    private static toDate;
+    private static assertDateBucketUnit;
+    private static assertDateRange;
+    private static isRecord;
+}

package/dist/shared/utils/TimeSeriesBucketUtils.js

@@ -0,0 +1,430 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { __publicField } from '../../chunk-S7EYY36U.js';
+var _TimeSeriesBucketUtils = /*#__PURE__*/ function() {
+    "use strict";
+    function _TimeSeriesBucketUtils() {
+        _class_call_check(this, _TimeSeriesBucketUtils);
+    }
+    _create_class(_TimeSeriesBucketUtils, null, [
+        {
+            key: "fillMissingUtcBuckets",
+            value: /**
+   * 시계열 데이터에서 누락된 UTC bucket row를 채운다.
+   *
+   * 특징:
+   * - 모든 bucket 계산은 UTC 기준으로 처리한다.
+   * - 출력 dateKey 값은 항상 ISO 문자열이다.
+   * - dateRange가 없으면 rows 내 가장 과거/미래 bucket을 사용한다.
+   * - dateRange 양쪽 값이 모두 있으면 순서와 무관하게 더 과거 값이 start가 된다.
+   * - 동일 bucket으로 정규화되는 row가 2개 이상이면 throw 한다.
+   *
+   * 주의:
+   * - number date input은 JavaScript Date 생성자와 동일하게 millisecond timestamp로 처리된다.
+   * - string date input의 파싱은 new Date(value)에 위임한다.
+   */ function fillMissingUtcBuckets(rows, options) {
+                if (!Array.isArray(rows)) {
+                    throw new TypeError("rows must be an array.");
+                }
+                if (!_TimeSeriesBucketUtils.isRecord(options)) {
+                    throw new TypeError("options must be an object.");
+                }
+                var dateKey = options.dateKey, unit = options.unit, fillValues = options.fillValues, dateRange = options.dateRange;
+                if (typeof dateKey !== "string" || dateKey.length === 0) {
+                    throw new TypeError("dateKey must be a non-empty string.");
+                }
+                _TimeSeriesBucketUtils.assertDateBucketUnit(unit);
+                if (dateRange !== void 0) {
+                    _TimeSeriesBucketUtils.assertDateRange(dateRange);
+                }
+                if (fillValues !== void 0 && typeof fillValues !== "function" && !_TimeSeriesBucketUtils.isRecord(fillValues)) {
+                    throw new TypeError("fillValues must be an object or a function.");
+                }
+                var normalizedRows = [];
+                var minBucketTime;
+                var maxBucketTime;
+                for(var index = 0; index < rows.length; index += 1){
+                    var row = rows[index];
+                    if (!_TimeSeriesBucketUtils.isRecord(row)) {
+                        throw new TypeError("rows[".concat(index, "] must be an object."));
+                    }
+                    if (!(dateKey in row)) {
+                        throw new Error("rows[".concat(index, '] does not have dateKey "').concat(dateKey, '".'));
+                    }
+                    var rawDate = row[dateKey];
+                    var bucketDate = _TimeSeriesBucketUtils.startOfUtcBucket(rawDate, unit, "rows[".concat(index, "].").concat(dateKey));
+                    var bucketTime = bucketDate.getTime();
+                    var isoDate = bucketDate.toISOString();
+                    normalizedRows.push({
+                        row: row,
+                        isoDate: isoDate,
+                        bucketTime: bucketTime
+                    });
+                    minBucketTime = minBucketTime === void 0 ? bucketTime : Math.min(minBucketTime, bucketTime);
+                    maxBucketTime = maxBucketTime === void 0 ? bucketTime : Math.max(maxBucketTime, bucketTime);
+                }
+                var resolvedRange = _TimeSeriesBucketUtils.resolveUtcBucketRange(minBucketTime, maxBucketTime, unit, dateRange);
+                if (resolvedRange === null) {
+                    return [];
+                }
+                var rangeStart = resolvedRange.start, rangeEnd = resolvedRange.end;
+                if (rangeStart.getTime() > rangeEnd.getTime()) {
+                    throw new Error("Resolved dateRange start must be less than or equal to resolved dateRange end.");
+                }
+                var rangeStartTime = rangeStart.getTime();
+                var rangeEndTime = rangeEnd.getTime();
+                var bucketMap = /* @__PURE__ */ new Map();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = normalizedRows[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var normalizedRow = _step.value;
+                        if (normalizedRow.bucketTime < rangeStartTime || normalizedRow.bucketTime > rangeEndTime) {
+                            continue;
+                        }
+                        if (bucketMap.has(normalizedRow.isoDate)) {
+                            throw new Error('Duplicate UTC bucket detected for "'.concat(dateKey, '": ').concat(normalizedRow.isoDate, ". Pre-aggregate or de-duplicate rows before calling fillMissingUtcBuckets."));
+                        }
+                        bucketMap.set(normalizedRow.isoDate, _object_spread_props(_object_spread({}, normalizedRow.row), _define_property({}, dateKey, normalizedRow.isoDate)));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                var result = [];
+                var resolvedFillValues = fillValues === void 0 ? {} : fillValues;
+                var cursor = rangeStart;
+                while(cursor.getTime() <= rangeEndTime){
+                    var isoDate1 = cursor.toISOString();
+                    var existingRow = bucketMap.get(isoDate1);
+                    if (existingRow) {
+                        result.push(existingRow);
+                    } else {
+                        var valuesToFill = typeof resolvedFillValues === "function" ? resolvedFillValues({
+                            isoDate: isoDate1,
+                            date: new Date(cursor.getTime()),
+                            unit: unit
+                        }) : resolvedFillValues;
+                        if (!_TimeSeriesBucketUtils.isRecord(valuesToFill)) {
+                            throw new TypeError("fillValues function must return an object.");
+                        }
+                        result.push(_object_spread_props(_object_spread({}, valuesToFill), _define_property({}, dateKey, isoDate1)));
+                    }
+                    cursor = _TimeSeriesBucketUtils.addUtcBucketUnit(cursor, unit);
+                }
+                return result;
+            }
+        },
+        {
+            key: "resolveUtcBucketRange",
+            value: function resolveUtcBucketRange(minBucketTime, maxBucketTime, unit, dateRange) {
+                var hasRows = minBucketTime !== void 0 && maxBucketTime !== void 0;
+                if (dateRange === void 0) {
+                    if (!hasRows) {
+                        return null;
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                var _dateRange = _sliced_to_array(dateRange, 2), left = _dateRange[0], right = _dateRange[1];
+                var hasLeft = left !== null && left !== void 0;
+                var hasRight = right !== null && right !== void 0;
+                if (!hasLeft && !hasRight) {
+                    if (!hasRows) {
+                        return null;
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                if (hasLeft && hasRight) {
+                    var leftBucket = _TimeSeriesBucketUtils.startOfUtcBucket(left, unit, "dateRange[0]");
+                    var rightBucket = _TimeSeriesBucketUtils.startOfUtcBucket(right, unit, "dateRange[1]");
+                    if (leftBucket.getTime() <= rightBucket.getTime()) {
+                        return {
+                            start: leftBucket,
+                            end: rightBucket
+                        };
+                    }
+                    return {
+                        start: rightBucket,
+                        end: leftBucket
+                    };
+                }
+                if (hasLeft) {
+                    if (!hasRows) {
+                        throw new Error("dateRange[1] is nullish, so rows are required to infer dateRange end.");
+                    }
+                    return {
+                        start: _TimeSeriesBucketUtils.startOfUtcBucket(left, unit, "dateRange[0]"),
+                        end: _TimeSeriesBucketUtils.startOfUtcBucket(maxBucketTime, unit, "inferred dateRange end")
+                    };
+                }
+                if (!hasRows) {
+                    throw new Error("dateRange[0] is nullish, so rows are required to infer dateRange start.");
+                }
+                return {
+                    start: _TimeSeriesBucketUtils.startOfUtcBucket(minBucketTime, unit, "inferred dateRange start"),
+                    end: _TimeSeriesBucketUtils.startOfUtcBucket(right, unit, "dateRange[1]")
+                };
+            }
+        },
+        {
+            key: "startOfUtcBucket",
+            value: function startOfUtcBucket(value, unit, argumentName) {
+                var date = _TimeSeriesBucketUtils.toDate(value, argumentName);
+                var year = date.getUTCFullYear();
+                var month = date.getUTCMonth();
+                var day = date.getUTCDate();
+                var hour = date.getUTCHours();
+                var minute = date.getUTCMinutes();
+                var second = date.getUTCSeconds();
+                switch(unit){
+                    case "year":
+                        return new Date(Date.UTC(year, 0, 1, 0, 0, 0, 0));
+                    case "quarter":
+                        {
+                            var quarterStartMonth = Math.floor(month / 3) * 3;
+                            return new Date(Date.UTC(year, quarterStartMonth, 1, 0, 0, 0, 0));
+                        }
+                    case "month":
+                        return new Date(Date.UTC(year, month, 1, 0, 0, 0, 0));
+                    case "week":
+                        {
+                            var dayOfWeek = new Date(Date.UTC(year, month, day)).getUTCDay();
+                            var daysSinceMonday = (dayOfWeek + 6) % 7;
+                            return new Date(Date.UTC(year, month, day - daysSinceMonday, 0, 0, 0, 0));
+                        }
+                    case "day":
+                        return new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+                    case "hour":
+                        return new Date(Date.UTC(year, month, day, hour, 0, 0, 0));
+                    case "minute":
+                        return new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+                    case "second":
+                        return new Date(Date.UTC(year, month, day, hour, minute, second, 0));
+                }
+            }
+        },
+        {
+            key: "addUtcBucketUnit",
+            value: function addUtcBucketUnit(date, unit) {
+                var next = new Date(date.getTime());
+                switch(unit){
+                    case "year":
+                        next.setUTCFullYear(next.getUTCFullYear() + 1);
+                        break;
+                    case "quarter":
+                        next.setUTCMonth(next.getUTCMonth() + 3);
+                        break;
+                    case "month":
+                        next.setUTCMonth(next.getUTCMonth() + 1);
+                        break;
+                    case "week":
+                        next.setUTCDate(next.getUTCDate() + 7);
+                        break;
+                    case "day":
+                        next.setUTCDate(next.getUTCDate() + 1);
+                        break;
+                    case "hour":
+                        next.setUTCHours(next.getUTCHours() + 1);
+                        break;
+                    case "minute":
+                        next.setUTCMinutes(next.getUTCMinutes() + 1);
+                        break;
+                    case "second":
+                        next.setUTCSeconds(next.getUTCSeconds() + 1);
+                        break;
+                }
+                return _TimeSeriesBucketUtils.startOfUtcBucket(next, unit, "date");
+            }
+        },
+        {
+            key: "toDate",
+            value: function toDate(value, argumentName) {
+                var isSupportedDateInput = typeof value === "string" || typeof value === "number" || _instanceof(value, Date);
+                if (!isSupportedDateInput) {
+                    throw new TypeError("".concat(argumentName, " must be a string, number timestamp, or Date instance."));
+                }
+                var date = _instanceof(value, Date) ? new Date(value.getTime()) : new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error("".concat(argumentName, " must be a valid date value."));
+                }
+                return date;
+            }
+        },
+        {
+            key: "assertDateBucketUnit",
+            value: function assertDateBucketUnit(unit) {
+                if (!_TimeSeriesBucketUtils.DATE_BUCKET_UNITS.includes(unit)) {
+                    throw new TypeError("unit must be one of: ".concat(_TimeSeriesBucketUtils.DATE_BUCKET_UNITS.join(", "), "."));
+                }
+            }
+        },
+        {
+            key: "assertDateRange",
+            value: function assertDateRange(dateRange) {
+                if (!Array.isArray(dateRange) || dateRange.length !== 2) {
+                    throw new TypeError("dateRange must be a tuple with exactly two items.");
+                }
+            }
+        },
+        {
+            key: "isRecord",
+            value: function isRecord(value) {
+                return (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null && !Array.isArray(value);
+            }
+        }
+    ]);
+    return _TimeSeriesBucketUtils;
+}();
+__publicField(_TimeSeriesBucketUtils, "DATE_BUCKET_UNITS", [
+    "year",
+    "quarter",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second"
+]);
+var TimeSeriesBucketUtils = _TimeSeriesBucketUtils;
+export { TimeSeriesBucketUtils };

package/dist/shared/utils/TimeSeriesBucketUtils.types.cjs

@@ -0,0 +1 @@
+'use strict';

package/dist/shared/utils/TimeSeriesBucketUtils.types.d.ts

@@ -0,0 +1,41 @@
+export type DateBucketUnit = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
+export type DateBucketInput = string | number | Date;
+export type DateBucketRange = readonly [
+    DateBucketInput | null | undefined,
+    DateBucketInput | null | undefined
+];
+export type FilledUtcBucketRow<T extends object, K extends Extract<keyof T, string>> = Omit<Partial<T>, K> & Record<K, string>;
+export interface FillMissingUtcBucketsOptions<T extends object, K extends Extract<keyof T, string>> {
+    /**
+     * 날짜 값이 들어있는 row field key.
+     *
+     * 해당 field value는 runtime 기준 string | number | Date 여야 한다.
+     */
+    dateKey: K;
+    /**
+     * UTC 기준 bucket 단위.
+     */
+    unit: DateBucketUnit;
+    /**
+     * 누락된 bucket row에 채워 넣을 값.
+     *
+     * 예:
+     * { count: 0 }
+     */
+    fillValues?: Omit<Partial<T>, K> | ((context: {
+        isoDate: string;
+        date: Date;
+        unit: DateBucketUnit;
+    }) => Omit<Partial<T>, K>);
+    /**
+     * 출력할 bucket range.
+     *
+     * - [a, b]: 순서와 무관하게 더 과거 값이 start, 더 미래 값이 end
+     * - [null, b] 또는 [undefined, b]: b를 end로 사용하고 start는 rows에서 추론
+     * - [a, null] 또는 [a, undefined]: a를 start로 사용하고 end는 rows에서 추론
+     * - 생략 또는 [null, undefined]: start/end 모두 rows에서 추론
+     *
+     * number는 JavaScript Date 생성자와 동일하게 millisecond timestamp로 처리된다.
+     */
+    dateRange?: DateBucketRange;
+}

package/dist/shared/utils/index.cjs

@@ -3,6 +3,7 @@ var global = require('./global');
 var ArrayUtils = require('./ArrayUtils');
 var AxiosUtils = require('./AxiosUtils');
 var StringUtils = require('./StringUtils');
+var TimeSeriesBucketUtils = require('./TimeSeriesBucketUtils');
 var Uint8ArrayUtils = require('./Uint8ArrayUtils');
 var UuidUtils = require('./UuidUtils');
 var BooleanUtils = require('./BooleanUtils');
@@ -55,6 +56,14 @@ Object.keys(StringUtils).forEach(function(k) {
         }
     });
 });
+Object.keys(TimeSeriesBucketUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return TimeSeriesBucketUtils[k];
+        }
+    });
+});
 Object.keys(Uint8ArrayUtils).forEach(function(k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
         enumerable: true,

package/dist/shared/utils/index.d.ts

@@ -2,6 +2,8 @@ export * from './global/index.js';
 export * from './ArrayUtils.js';
 export * from './AxiosUtils.js';
 export * from './StringUtils.js';
+export * from "./TimeSeriesBucketUtils.js";
+export type * from "./TimeSeriesBucketUtils.types.js";
 export * from './Uint8ArrayUtils.js';
 export * from './UuidUtils.js';
 export * from './BooleanUtils.js';

package/dist/shared/utils/index.js

@@ -2,6 +2,7 @@ export * from './global/index.js';
 export * from './ArrayUtils.js';
 export * from './AxiosUtils.js';
 export * from './StringUtils.js';
+export * from './TimeSeriesBucketUtils.js';
 export * from './Uint8ArrayUtils.js';
 export * from './UuidUtils.js';
 export * from './BooleanUtils.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,