@powfix/core-js 0.22.2 → 0.23.1

package/dist/node/utils/HookUtils.cjs

@@ -0,0 +1,87 @@
+'use strict';
+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;
+}
+require('../../chunk-ETV4XYOV.cjs');
+var HookUtils = /*#__PURE__*/ function() {
+    function HookUtils() {
+        _class_call_check(this, HookUtils);
+    }
+    _create_class(HookUtils, null, [
+        {
+            key: "getFkChanges",
+            value: function getFkChanges(pFkValue, cFkValue) {
+                var results = {
+                    pFkValue: null,
+                    cFkValue: null
+                };
+                if (pFkValue !== void 0 && cFkValue !== void 0) {
+                    if (pFkValue !== cFkValue) {
+                        if (pFkValue !== null) {
+                            results.pFkValue = pFkValue;
+                        }
+                    }
+                }
+                if (cFkValue !== null && cFkValue !== void 0) {
+                    results.cFkValue = cFkValue;
+                }
+                return results;
+            }
+        },
+        {
+            key: "makeModelHooks",
+            value: function makeModelHooks(model, fns) {
+                return [
+                    {
+                        model: model,
+                        hookType: "afterCreate",
+                        fn: fns.create
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkCreate",
+                        fn: fns.create
+                    },
+                    {
+                        model: model,
+                        hookType: "afterUpdate",
+                        fn: fns.update
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkUpdate",
+                        fn: fns.update
+                    },
+                    {
+                        model: model,
+                        hookType: "afterDestroy",
+                        fn: fns.destroy
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkDestroy",
+                        fn: fns.destroy
+                    }
+                ];
+            }
+        }
+    ]);
+    return HookUtils;
+}();
+exports.HookUtils = HookUtils;

package/dist/node/utils/HookUtils.d.ts

@@ -0,0 +1,20 @@
+import { Hook } from '../interfaces/db/sequelize/Hook.js';
+import { HookFn } from '../interfaces/db/sequelize/HookFn.js';
+import { ModelCtor } from 'sequelize-typescript';
+import '../interfaces/db/sequelize/HookType.js';
+import 'sequelize/types/hooks';
+import 'sequelize/types/model';
+
+declare class HookUtils {
+    static getFkChanges<T>(pFkValue: T | null | undefined, cFkValue: T | null | undefined): {
+        pFkValue: T | null;
+        cFkValue: T | null;
+    };
+    static makeModelHooks(model: ModelCtor, fns: {
+        create: HookFn;
+        update: HookFn;
+        destroy: HookFn;
+    }): Hook[];
+}
+
+export { HookUtils };

package/dist/node/utils/HookUtils.js

@@ -0,0 +1,87 @@
+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;
+}
+import '../../chunk-PKBMQBKP.js';
+var HookUtils = /*#__PURE__*/ function() {
+    "use strict";
+    function HookUtils() {
+        _class_call_check(this, HookUtils);
+    }
+    _create_class(HookUtils, null, [
+        {
+            key: "getFkChanges",
+            value: function getFkChanges(pFkValue, cFkValue) {
+                var results = {
+                    pFkValue: null,
+                    cFkValue: null
+                };
+                if (pFkValue !== void 0 && cFkValue !== void 0) {
+                    if (pFkValue !== cFkValue) {
+                        if (pFkValue !== null) {
+                            results.pFkValue = pFkValue;
+                        }
+                    }
+                }
+                if (cFkValue !== null && cFkValue !== void 0) {
+                    results.cFkValue = cFkValue;
+                }
+                return results;
+            }
+        },
+        {
+            key: "makeModelHooks",
+            value: function makeModelHooks(model, fns) {
+                return [
+                    {
+                        model: model,
+                        hookType: "afterCreate",
+                        fn: fns.create
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkCreate",
+                        fn: fns.create
+                    },
+                    {
+                        model: model,
+                        hookType: "afterUpdate",
+                        fn: fns.update
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkUpdate",
+                        fn: fns.update
+                    },
+                    {
+                        model: model,
+                        hookType: "afterDestroy",
+                        fn: fns.destroy
+                    },
+                    {
+                        model: model,
+                        hookType: "afterBulkDestroy",
+                        fn: fns.destroy
+                    }
+                ];
+            }
+        }
+    ]);
+    return HookUtils;
+}();
+export { HookUtils };

package/dist/node/utils/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+var sequelizeUtils = require('./sequelize-utils');
+var HookUtils = require('./HookUtils');
+Object.keys(sequelizeUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return sequelizeUtils[k];
+        }
+    });
+});
+Object.keys(HookUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return HookUtils[k];
+        }
+    });
+});

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

@@ -0,0 +1,10 @@
+export { SequelizeUtils } from './sequelize-utils/SequelizeUtils.js';
+export { ConcreteUuidKeys, ExtractStringKeys, ExtractUuidKeys, Model, NonKnownUuidStringKeys, UuidColumnOptionsBase, UuidColumnOptionsForModel } from './sequelize-utils/types.js';
+export { HookUtils } from './HookUtils.js';
+import 'sequelize';
+import '../interfaces/db/sequelize/Hook.js';
+import 'sequelize-typescript';
+import '../interfaces/db/sequelize/HookType.js';
+import 'sequelize/types/hooks';
+import 'sequelize/types/model';
+import '../interfaces/db/sequelize/HookFn.js';

package/dist/node/utils/index.js

@@ -0,0 +1,2 @@
+export * from './sequelize-utils';
+export * from './HookUtils';

package/dist/node/utils/sequelize-utils/SequelizeUtils.cjs

@@ -0,0 +1,165 @@
+'use strict';
+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 _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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var chunkETV4XYOV_cjs = require('../../../chunk-ETV4XYOV.cjs');
+var sequelize = require('sequelize');
+var UuidUtils = require('../../../shared/utils/UuidUtils');
+var constants = require('../../../shared/constants');
+var node = require('@powfix/uuid/node');
+var _SequelizeUtils = /*#__PURE__*/ function() {
+    function _SequelizeUtils() {
+        _class_call_check(this, _SequelizeUtils);
+    }
+    _create_class(_SequelizeUtils, null, [
+        {
+            key: "decimal2Number",
+            value: function decimal2Number(value) {
+                if (value === null || value === void 0) {
+                    return value;
+                }
+                var parsed = Number(value);
+                if (isNaN(parsed)) {
+                    throw new Error("value(typeof=".concat(typeof value === "undefined" ? "undefined" : _type_of(value), ", value=").concat(value, ") iNaN(is not number)"));
+                }
+                return parsed;
+            }
+        },
+        {
+            key: "buildUuidColumn",
+            value: function buildUuidColumn(options) {
+                var columnName = options.columnName, overrideOptions = _object_without_properties(options, [
+                    "columnName"
+                ]);
+                if (overrideOptions.allowNull) {
+                    return _object_spread({
+                        type: "binary(16)",
+                        get: function get() {
+                            var value = this.getDataValue(columnName);
+                            return value != null ? node.UUID.from(value) : value;
+                        },
+                        set: function set(input) {
+                            var value = input != null ? node.UUID.from(input).toBuffer() : input;
+                            this.setDataValue(columnName, value);
+                        }
+                    }, overrideOptions);
+                } else {
+                    return _object_spread({
+                        type: "binary(16)",
+                        get: function get() {
+                            var value = this.getDataValue(columnName);
+                            return node.UUID.from(value);
+                        },
+                        set: function set(input) {
+                            var value = node.UUID.from(input).toBuffer();
+                            this.setDataValue(columnName, value);
+                        }
+                    }, overrideOptions);
+                }
+            }
+        },
+        {
+            key: "getNullableArrayFilter",
+            value: function getNullableArrayFilter(arr) {
+                return _define_property({}, sequelize.Op.or, arr.map(function(value) {
+                    if (value === null) {
+                        return _define_property({}, sequelize.Op.is, value);
+                    } else if (value === constants.NOT_NULL) {
+                        return _define_property({}, sequelize.Op.not, null);
+                    } else {
+                        return _define_property({}, sequelize.Op.eq, value);
+                    }
+                }));
+            }
+        }
+    ]);
+    return _SequelizeUtils;
+}();
+chunkETV4XYOV_cjs.__publicField(_SequelizeUtils, "buildPrimaryUuidColumn", function() {
+    return _object_spread({}, _SequelizeUtils.buildUuidColumn({
+        columnName: "uuid",
+        allowNull: false,
+        primaryKey: true,
+        unique: true,
+        defaultValue: function() {
+            return node.UUID.from(UuidUtils.UuidUtils.v4()).toBuffer();
+        }
+    }));
+});
+var SequelizeUtils = _SequelizeUtils;
+exports.SequelizeUtils = SequelizeUtils;

package/dist/node/utils/sequelize-utils/SequelizeUtils.d.ts

@@ -0,0 +1,12 @@
+import { ModelAttributeColumnOptions, WhereOptions } from 'sequelize';
+import { Model, NonKnownUuidStringKeys, UuidColumnOptionsForModel, UuidColumnOptionsBase } from './types.js';
+
+declare class SequelizeUtils {
+    static decimal2Number(value: any): number | null | undefined;
+    static buildPrimaryUuidColumn: () => Partial<ModelAttributeColumnOptions>;
+    static buildUuidColumn<T extends Model, AdditionalKeys extends NonKnownUuidStringKeys<T> = never>(options: UuidColumnOptionsForModel<T, AdditionalKeys>): Partial<ModelAttributeColumnOptions>;
+    static buildUuidColumn(options: UuidColumnOptionsBase): Partial<ModelAttributeColumnOptions>;
+    static getNullableArrayFilter<T = undefined>(arr: (null | any)[]): WhereOptions<T>;
+}
+
+export { SequelizeUtils };

package/dist/node/utils/sequelize-utils/SequelizeUtils.js

@@ -0,0 +1,165 @@
+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 _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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { __publicField } from '../../../chunk-PKBMQBKP.js';
+import { Op } from 'sequelize';
+import { UuidUtils } from '../../../shared/utils/UuidUtils';
+import { NOT_NULL } from '../../../shared/constants';
+import { UUID } from '@powfix/uuid/node';
+var _SequelizeUtils = /*#__PURE__*/ function() {
+    "use strict";
+    function _SequelizeUtils() {
+        _class_call_check(this, _SequelizeUtils);
+    }
+    _create_class(_SequelizeUtils, null, [
+        {
+            key: "decimal2Number",
+            value: function decimal2Number(value) {
+                if (value === null || value === void 0) {
+                    return value;
+                }
+                var parsed = Number(value);
+                if (isNaN(parsed)) {
+                    throw new Error("value(typeof=".concat(typeof value === "undefined" ? "undefined" : _type_of(value), ", value=").concat(value, ") iNaN(is not number)"));
+                }
+                return parsed;
+            }
+        },
+        {
+            key: "buildUuidColumn",
+            value: function buildUuidColumn(options) {
+                var columnName = options.columnName, overrideOptions = _object_without_properties(options, [
+                    "columnName"
+                ]);
+                if (overrideOptions.allowNull) {
+                    return _object_spread({
+                        type: "binary(16)",
+                        get: function get() {
+                            var value = this.getDataValue(columnName);
+                            return value != null ? UUID.from(value) : value;
+                        },
+                        set: function set(input) {
+                            var value = input != null ? UUID.from(input).toBuffer() : input;
+                            this.setDataValue(columnName, value);
+                        }
+                    }, overrideOptions);
+                } else {
+                    return _object_spread({
+                        type: "binary(16)",
+                        get: function get() {
+                            var value = this.getDataValue(columnName);
+                            return UUID.from(value);
+                        },
+                        set: function set(input) {
+                            var value = UUID.from(input).toBuffer();
+                            this.setDataValue(columnName, value);
+                        }
+                    }, overrideOptions);
+                }
+            }
+        },
+        {
+            key: "getNullableArrayFilter",
+            value: function getNullableArrayFilter(arr) {
+                return _define_property({}, Op.or, arr.map(function(value) {
+                    if (value === null) {
+                        return _define_property({}, Op.is, value);
+                    } else if (value === NOT_NULL) {
+                        return _define_property({}, Op.not, null);
+                    } else {
+                        return _define_property({}, Op.eq, value);
+                    }
+                }));
+            }
+        }
+    ]);
+    return _SequelizeUtils;
+}();
+__publicField(_SequelizeUtils, "buildPrimaryUuidColumn", function() {
+    return _object_spread({}, _SequelizeUtils.buildUuidColumn({
+        columnName: "uuid",
+        allowNull: false,
+        primaryKey: true,
+        unique: true,
+        defaultValue: function() {
+            return UUID.from(UuidUtils.v4()).toBuffer();
+        }
+    }));
+});
+var SequelizeUtils = _SequelizeUtils;
+export { SequelizeUtils };

package/dist/node/utils/sequelize-utils/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+var SequelizeUtils = require('./SequelizeUtils');
+var types = require('./types');
+Object.keys(SequelizeUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return SequelizeUtils[k];
+        }
+    });
+});
+Object.keys(types).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return types[k];
+        }
+    });
+});

package/dist/node/utils/sequelize-utils/index.d.ts

@@ -0,0 +1,3 @@
+export { SequelizeUtils } from './SequelizeUtils.js';
+export { ConcreteUuidKeys, ExtractStringKeys, ExtractUuidKeys, Model, NonKnownUuidStringKeys, UuidColumnOptionsBase, UuidColumnOptionsForModel } from './types.js';
+import 'sequelize';

package/dist/node/utils/sequelize-utils/index.js

@@ -0,0 +1,2 @@
+export * from './SequelizeUtils';
+export * from './types';

package/dist/node/utils/sequelize-utils/types.cjs

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

package/dist/node/utils/sequelize-utils/types.d.ts

@@ -0,0 +1,19 @@
+import { ModelAttributeColumnOptions } from 'sequelize';
+
+type Model = Record<string, any> | undefined;
+type ExtractUuidKeys<T extends Model> = {
+    [Property in keyof T]: Property extends `${string}Uuid` | 'uuid' ? Property : never;
+}[keyof T];
+type ExtractStringKeys<T extends Model> = {
+    [Property in keyof T]: string extends T[Property] ? Property : never;
+}[keyof T];
+type ConcreteUuidKeys<T extends Model> = ExtractUuidKeys<T>;
+type NonKnownUuidStringKeys<T extends Model> = Exclude<ExtractStringKeys<T>, ConcreteUuidKeys<T>> & string;
+interface UuidColumnOptionsBase extends Omit<ModelAttributeColumnOptions, 'type'> {
+    columnName: string;
+}
+interface UuidColumnOptionsForModel<T extends Model, AdditionalKeys extends string> extends Omit<ModelAttributeColumnOptions, 'type'> {
+    columnName: ConcreteUuidKeys<T> | AdditionalKeys;
+}
+
+export type { ConcreteUuidKeys, ExtractStringKeys, ExtractUuidKeys, Model, NonKnownUuidStringKeys, UuidColumnOptionsBase, UuidColumnOptionsForModel };

package/dist/shared/constants/COORDINATE.cjs

@@ -0,0 +1,15 @@
+'use strict';
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var chunkETV4XYOV_cjs = require('../../chunk-ETV4XYOV.cjs');
+var COORDINATE = function COORDINATE() {
+    _class_call_check(this, COORDINATE);
+};
+chunkETV4XYOV_cjs.__publicField(COORDINATE, "LATITUDE_MIN_LENGTH", 1);
+chunkETV4XYOV_cjs.__publicField(COORDINATE, "LATITUDE_MAX_LENGTH", 10);
+chunkETV4XYOV_cjs.__publicField(COORDINATE, "LONGITUDE_MIN_LENGTH", 1);
+chunkETV4XYOV_cjs.__publicField(COORDINATE, "LONGITUDE_MAX_LENGTH", 11);
+exports.COORDINATE = COORDINATE;

package/dist/shared/constants/COORDINATE.d.ts

@@ -0,0 +1,9 @@
+declare class COORDINATE {
+    static LATITUDE_MIN_LENGTH: number;
+    static LATITUDE_MAX_LENGTH: number;
+    static LONGITUDE_MIN_LENGTH: number;
+    static LONGITUDE_MAX_LENGTH: number;
+}
+declare namespace COORDINATE { }
+
+export { COORDINATE };

package/dist/shared/constants/COORDINATE.js

@@ -0,0 +1,15 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+import { __publicField } from '../../chunk-PKBMQBKP.js';
+var COORDINATE = function COORDINATE() {
+    "use strict";
+    _class_call_check(this, COORDINATE);
+};
+__publicField(COORDINATE, "LATITUDE_MIN_LENGTH", 1);
+__publicField(COORDINATE, "LATITUDE_MAX_LENGTH", 10);
+__publicField(COORDINATE, "LONGITUDE_MIN_LENGTH", 1);
+__publicField(COORDINATE, "LONGITUDE_MAX_LENGTH", 11);
+export { COORDINATE };