@leyyo/common 1.0.1 → 1.0.3

package/dist/hook/common-hook-impl.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHookImpl = void 0;
+const internal_1 = require("../internal");
+const exception_1 = require("../exception");
+// noinspection JSUnusedGlobalSymbols
+class CommonHookImpl {
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor() {
+        // clear after 1 minute
+        setTimeout(() => this._clearPending(), 60000);
+    }
+    $init(leyyo) {
+        this._waitingForCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForCallbacks`);
+        this._attachedCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/attachedCallbacks`);
+        this._waitingForProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForProviders`);
+        this._definedProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/definedProviders`);
+    }
+    /**
+     * Clear jobs in the queue which channel as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    _clearPending() {
+        for (const [channel,] of this._waitingForCallbacks.entries()) {
+            const rec = this._attachedCallbacks.get(channel);
+            if (rec && !rec.initialization) {
+                continue;
+            }
+            this._waitingForCallbacks.delete(channel);
+            console.log(`hook.cleared.pending => {channel: ${channel}}`);
+        }
+    }
+    get $secure() {
+        return this;
+    }
+    attachCallback(channel, fn) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback attached
+        this._attachedCallbacks.set(channel, { fn });
+        // check waiting records, to be called
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).forEach(item => {
+                fn(...item);
+            });
+            this._waitingForCallbacks.delete(channel);
+        }
+    }
+    queueForCallback(channel, ...args) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback already exists
+        if (this._attachedCallbacks.has(channel)) {
+            const rec = this._attachedCallbacks.get(channel);
+            rec.fn(...args);
+            return true;
+        }
+        // callback does not exist yet, so wait to be attached
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).push(args);
+        }
+        else {
+            this._waitingForCallbacks.set(channel, [args]);
+        }
+        return false;
+    }
+    get $back() {
+        return undefined;
+    }
+    whenProviderDefined(channel, consumer, callback) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        if (!this._waitingForProviders.has(channel)) {
+            this._waitingForProviders.set(channel, []);
+        }
+        if (this._definedProviders.has(channel)) {
+            const ins = this._definedProviders.get(channel);
+            if (ins.producer !== consumer) {
+                callback(ins);
+            }
+        }
+        this._waitingForProviders.get(channel).push({ consumer, callback });
+    }
+    defineProvider(channel, producer, instance) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        const ins = Object.assign(Object.assign({}, instance), { producer });
+        this._definedProviders.set(channel, ins);
+        if (instance.proper) {
+            if (this._waitingForProviders.has(channel)) {
+                this._waitingForProviders.get(channel).forEach(item => {
+                    if (item.consumer !== producer) {
+                        item.callback(instance);
+                    }
+                });
+            }
+        }
+    }
+}
+exports.CommonHookImpl = CommonHookImpl;

package/dist/hook/index-types.d.ts

@@ -0,0 +1,56 @@
+import { Arr, HookDefinedProvider, HookDefinedProviderLambda, InitLike, ShiftMain, ShiftSecure } from "../shared";
+/**
+ * Hook interface, it collects all jobs and fire them when callback is defined
+ * */
+export interface CommonHook extends ShiftSecure<CommonHookSecure> {
+    /**
+     * Attach a callback
+     *
+     * @param {string} channel
+     * @param {Function} fn
+     *
+     * Notes:
+     * - channel should be regular string
+     * - After attached, it should call all waiting calls in the queue
+     * */
+    attachCallback(channel: string, fn: Function): void;
+    /**
+     * Add a call into queue, which to be executed by appropriate callback
+     *
+     * @param {string} channel
+     * @param {Array<any>} args
+     * @returns {boolean} - channel exists?
+     *
+     * Notes:
+     * - channel should be regular string
+     * */
+    queueForCallback(channel: string, ...args: Arr): boolean;
+    /**
+     * Informs when callback is changed
+     *
+     * @param {string} channel
+     * @param {Function} consumer
+     * @param {HookDefinedProviderLambda} callback
+     *
+     * Notes:
+     * - channel should be regular string
+     * - callback should be regular function
+     * - channel should not be already defined
+     * */
+    whenProviderDefined<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, consumer: Function, callback: HookDefinedProviderLambda<T>): void;
+    /**
+     * Defines a provider to replace temporary providers
+     *
+     * @param {string} channel
+     * @param {Function} producer
+     * @param {Object} instance
+     *
+     * Notes:
+     * - channel should be regular string
+     * */
+    defineProvider<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, producer: Function, instance: T): void;
+}
+/**
+ * Secure hook interface
+ * */
+export type CommonHookSecure = ShiftMain<CommonHook> & InitLike;

package/dist/hook/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hook/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './common-hook-impl';

package/dist/hook/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./common-hook-impl"), exports);

package/dist/index.d.ts

@@ -1,7 +1,13 @@
+export * from './exception';
+export * from './literal';
+export * from './shared';
 import { leyyo } from "./leyyo";
-export * from './aliases';
-export * from './constants';
-export * from './literals';
 declare const is: import("./is").CommonIs;
-declare const callback: import("./callback").CommonCallback;
-export { leyyo, is, callback };
+declare const hook: import("./hook").CommonHook;
+declare const assertion: import("./assertion").CommonAssertion;
+declare const storage: import("./storage").CommonStorage;
+declare const to: import("./to").CommonTo;
+declare const commonFqn: import("./fqn").CommonFqn;
+declare const commonLog: import("./log").CommonLog;
+declare const commonError: import("./error").CommonError;
+export { leyyo, is, hook, assertion, storage, to, commonFqn, commonLog, commonError };

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+// noinspection JSUnusedGlobalSymbols
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,13 +15,25 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callback = exports.is = exports.leyyo = void 0;
+exports.commonError = exports.commonLog = exports.commonFqn = exports.to = exports.storage = exports.assertion = exports.hook = exports.is = exports.leyyo = void 0;
+__exportStar(require("./exception"), exports);
+__exportStar(require("./literal"), exports);
+__exportStar(require("./shared"), exports);
 const leyyo_1 = require("./leyyo");
 Object.defineProperty(exports, "leyyo", { enumerable: true, get: function () { return leyyo_1.leyyo; } });
-__exportStar(require("./aliases"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./literals"), exports);
 const is = leyyo_1.leyyo.is;
 exports.is = is;
-const callback = leyyo_1.leyyo.callback;
-exports.callback = callback;
+const hook = leyyo_1.leyyo.hook;
+exports.hook = hook;
+const assertion = leyyo_1.leyyo.assertion;
+exports.assertion = assertion;
+const storage = leyyo_1.leyyo.storage;
+exports.storage = storage;
+const to = leyyo_1.leyyo.to;
+exports.to = to;
+const commonFqn = leyyo_1.leyyo.fqn;
+exports.commonFqn = commonFqn;
+const commonLog = leyyo_1.leyyo.log;
+exports.commonLog = commonLog;
+const commonError = leyyo_1.leyyo.error;
+exports.commonError = commonError;

package/dist/is/common-is-impl.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonIsImpl = void 0;
-const literals_1 = require("../literals");
+const literal_1 = require("../literal");
 // noinspection JSUnusedGlobalSymbols, JSUnusedLocalSymbols
 /** @inheritDoc */
 class CommonIsImpl {
@@ -12,15 +12,15 @@ class CommonIsImpl {
     }
     /** @inheritDoc */
     primitive(value) {
-        return literals_1.PrimitiveItems.includes((typeof value));
+        return literal_1.PrimitiveItems.includes((typeof value));
     }
     /** @inheritDoc */
     realValue(value) {
-        return literals_1.RealValueItems.includes((typeof value));
+        return literal_1.RealValueItems.includes((typeof value));
     }
     /** @inheritDoc */
     key(value) {
-        return literals_1.KeyValueItems.includes((typeof value));
+        return literal_1.KeyValueItems.includes((typeof value));
     }
     /** @inheritDoc */
     object(value) {
@@ -65,13 +65,13 @@ class CommonIsImpl {
     /** @inheritDoc */
     true(value) {
         return (value === true) ||
-            (this.text(value) && literals_1.WeakTrueItems.includes(value.toLowerCase())) ||
+            (this.text(value) && literal_1.WeakTrueItems.includes(value.toLowerCase())) ||
             (this.number(value) && value > 0);
     }
     /** @inheritDoc */
     false(value) {
         return (value === false) ||
-            (this.text(value) && literals_1.WeakFalseItems.includes(value.toLowerCase())) ||
+            (this.text(value) && literal_1.WeakFalseItems.includes(value.toLowerCase())) ||
             (this.number(value) && value <= 0);
     }
     // endregion is

package/dist/is/index-types.d.ts

@@ -1,4 +1,4 @@
-import { InitLike, ShiftMain, ShiftSecure } from "../aliases";
+import { InitLike, ShiftMain, ShiftSecure } from "../shared";
 /**
  * Basic is commands to easy use
  * */
@@ -141,5 +141,4 @@ export interface CommonIs extends ShiftSecure<CommonIsSecure> {
      * */
     false(value: any): boolean;
 }
-export interface CommonIsSecure extends ShiftMain<CommonIs>, InitLike {
-}
+export type CommonIsSecure = ShiftMain<CommonIs> & InitLike;

package/dist/leyyo/index-types.d.ts

@@ -1,16 +1,18 @@
-import { CommonCallback } from "../callback";
+import { CommonHook } from "../hook";
 import { CommonIs } from "../is";
 import { CommonAssertion } from "../assertion";
 import { CommonError } from "../error";
 import { CommonLog } from "../log";
 import { CommonStorage } from "../storage";
 import { CommonTo } from "../to";
+import { CommonFqn } from "../fqn";
 export interface Leyyo {
     readonly is: CommonIs;
-    readonly callback: CommonCallback;
+    readonly hook: CommonHook;
     readonly assertion: CommonAssertion;
     readonly error: CommonError;
     readonly log: CommonLog;
     readonly storage: CommonStorage;
     readonly to: CommonTo;
+    readonly fqn: CommonFqn;
 }

package/dist/leyyo/leyyo-impl.d.ts

@@ -1,4 +1,4 @@
-import { CommonCallback } from "../callback";
+import { CommonHook } from "../hook";
 import { Leyyo } from "./index-types";
 import { CommonIs } from "../is";
 import { CommonAssertion } from "../assertion";
@@ -6,14 +6,16 @@ import { CommonError } from "../error";
 import { CommonLog } from "../log";
 import { CommonStorage } from "../storage";
 import { CommonTo } from "../to";
+import { CommonFqn } from "../fqn";
 export declare class LeyyoImpl implements Leyyo {
-    readonly callback: CommonCallback;
+    readonly hook: CommonHook;
     readonly is: CommonIs;
     readonly assertion: CommonAssertion;
     readonly error: CommonError;
     readonly log: CommonLog;
     readonly storage: CommonStorage;
     readonly to: CommonTo;
+    readonly fqn: CommonFqn;
     constructor();
     private init;
     private postInit;

package/dist/leyyo/leyyo-impl.js

@@ -1,25 +1,32 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.leyyo = exports.LeyyoImpl = void 0;
-const callback_1 = require("../callback");
+const hook_1 = require("../hook");
 const is_1 = require("../is");
 const assertion_1 = require("../assertion");
 const error_1 = require("../error");
 const log_1 = require("../log");
 const storage_1 = require("../storage");
 const to_1 = require("../to");
-const constants_1 = require("../constants");
+const shared_1 = require("../shared");
 const internal_1 = require("../internal");
-const literals_1 = require("../literals");
+const literal_1 = require("../literal");
+const exception_1 = require("../exception");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fqn_1 = require("../fqn");
 class LeyyoImpl {
     constructor() {
         this.is = new is_1.CommonIsImpl();
         this.storage = new storage_1.CommonStorageImpl();
-        this.callback = new callback_1.CommonCallbackImpl(); // storage
-        this.log = new log_1.CommonLogImpl(); // callback
-        this.error = new error_1.CommonErrorImpl(); // callback
-        this.assertion = new assertion_1.CommonAssertionImpl(); // is, callback
-        this.to = new to_1.CommonToImpl(); // is, callback, assertion
+        this.hook = new hook_1.CommonHookImpl(); // storage
+        this.log = new log_1.CommonLogImpl(); // hook
+        this.error = new error_1.CommonErrorImpl(); // hook
+        this.assertion = new assertion_1.CommonAssertionImpl(); // is, hook
+        this.to = new to_1.CommonToImpl(); // is, hook, assertion
+        this.fqn = new fqn_1.CommonFqnImpl(); // hook
         this.init();
         this.postInit();
         this.initFqnRegister();
@@ -29,42 +36,58 @@ class LeyyoImpl {
     init() {
         this.is.$secure.$init(this);
         this.storage.$secure.$init(this);
-        this.callback.$secure.$init(this);
+        this.hook.$secure.$init(this);
         this.log.$secure.$init(this);
         this.error.$secure.$init(this);
         this.assertion.$secure.$init(this);
         this.to.$secure.$init(this);
     }
     postInit() {
-        (0, assertion_1.$$setLeyyo)(this);
+        (0, shared_1.$$setLeyyo)(this);
         log_1.LoggerImpl.$setLeyyo(this);
-        error_1.Exception.$setLeyyo(this);
+        exception_1.Exception.$setLeyyo(this);
     }
     initFqnRegister() {
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, is_1.CommonIsImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, storage_1.CommonStorageImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, callback_1.CommonCallbackImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, log_1.CommonLogImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, error_1.CommonErrorImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, assertion_1.CommonAssertionImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, to_1.CommonToImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, storage_1.List, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, log_1.LoggerImpl, 'class', internal_1.FQN_PCK);
-        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, assertion_1.assert, 'function', internal_1.FQN_PCK);
+        this.fqn.register(null, is_1.CommonIsImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, storage_1.CommonStorageImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, hook_1.CommonHookImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, fqn_1.CommonFqnImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, log_1.CommonLogImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, error_1.CommonErrorImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, assertion_1.CommonAssertionImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, to_1.CommonToImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, shared_1.List, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, log_1.LoggerImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, node_assert_1.default, 'function', internal_1.FQN_PCK);
     }
     initErrorRegister() {
-        [error_1.Exception, error_1.AssertionException, error_1.CausedException, error_1.DeveloperException, error_1.MultipleException].forEach(cls => {
-            this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, cls, 'class', internal_1.FQN_PCK);
-            this.callback.queueForCallback(constants_1.LY_PENDING_ERROR_REGISTER, cls);
+        [exception_1.Exception, exception_1.AssertionException, exception_1.CausedException, exception_1.DeveloperException, exception_1.MultipleException].forEach(cls => {
+            this.fqn.register(null, cls, 'class', internal_1.FQN_PCK);
+            this.error.register(cls);
         });
     }
     initEnumRegister() {
-        [literals_1.PrimitiveItems, literals_1.StorageTypeItems, literals_1.RealValueItems, literals_1.KeyValueItems, literals_1.WeakTrueItems, literals_1.WeakFalseItems,
-            literals_1.HttpMethodItems, literals_1.HttpPlaceItems, literals_1.SeverityItems, literals_1.EnvironmentItems,
-            literals_1.CountryCodeItems, literals_1.LanguageCodeItems, literals_1.LocaleCodeItems].forEach(enm => {
-            this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, enm, 'enum', internal_1.FQN_PCK);
-            this.callback.queueForCallback(constants_1.LY_PENDING_ENUM_REGISTER, enm);
-        });
+        const enumMap = {
+            Primitive: literal_1.PrimitiveItems,
+            StorageType: literal_1.StorageTypeItems,
+            RealValue: literal_1.RealValueItems,
+            KeyValue: literal_1.KeyValueItems,
+            WeakTrue: literal_1.WeakTrueItems,
+            WeakFalse: literal_1.WeakFalseItems,
+            HttpMethod: literal_1.HttpMethodItems,
+            HttpPlace: literal_1.HttpPlaceItems,
+            Severity: literal_1.SeverityItems,
+            Environment: literal_1.EnvironmentItems,
+            CountryCode: literal_1.CountryCodeItems,
+            LanguageCode: literal_1.LanguageCodeItems,
+            LocaleCode: literal_1.LocaleCodeItems,
+            SysClass: literal_1.SysClassItems,
+            SysFunction: literal_1.SysFunctionItems,
+        };
+        for (const [name, value] of Object.entries(enumMap)) {
+            this.fqn.register(name, value, 'enum', internal_1.FQN_PCK);
+            this.hook.queueForCallback(shared_1.LY_PENDING_ENUM_REGISTER, value);
+        }
     }
 }
 exports.LeyyoImpl = LeyyoImpl;

package/dist/literal/country-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Country code items
+ * */
+export declare const CountryCodeItems: readonly ["AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CS", "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW"];
+/**
+ * Country code
+ * */
+export type CountryCode = typeof CountryCodeItems[number];

package/dist/literal/country-code.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountryCodeItems = void 0;
+/**
+ * Country code items
+ * */
+exports.CountryCodeItems = ['AD', 'AE', 'AF', 'AG', 'AI', 'AL', 'AM', 'AN', 'AO', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AW', 'AX',
+    'AZ', 'BA', 'BB', 'BD', 'BE', 'BF', 'BG', 'BH', 'BI', 'BJ', 'BM', 'BN', 'BO', 'BR', 'BS', 'BT', 'BV', 'BW', 'BY', 'BZ', 'CA', 'CC', 'CD',
+    'CF', 'CG', 'CH', 'CI', 'CK', 'CL', 'CM', 'CN', 'CO', 'CR', 'CS', 'CU', 'CV', 'CX', 'CY', 'CZ', 'DE', 'DJ', 'DK', 'DM', 'DO', 'DZ', 'EC',
+    'EE', 'EG', 'EH', 'ER', 'ES', 'ET', 'FI', 'FJ', 'FK', 'FM', 'FO', 'FR', 'GA', 'GB', 'GD', 'GE', 'GF', 'GG', 'GH', 'GI', 'GL', 'GM', 'GN',
+    'GP', 'GQ', 'GR', 'GS', 'GT', 'GU', 'GW', 'GY', 'HK', 'HM', 'HN', 'HR', 'HT', 'HU', 'ID', 'IE', 'IL', 'IM', 'IN', 'IO', 'IQ', 'IR', 'IS',
+    'IT', 'JE', 'JM', 'JO', 'JP', 'KE', 'KG', 'KH', 'KI', 'KM', 'KN', 'KP', 'KR', 'KW', 'KY', 'KZ', 'LA', 'LB', 'LC', 'LI', 'LK', 'LR', 'LS',
+    'LT', 'LU', 'LV', 'LY', 'MA', 'MC', 'MD', 'MG', 'MH', 'MK', 'ML', 'MM', 'MN', 'MO', 'MP', 'MQ', 'MR', 'MS', 'MT', 'MU', 'MV', 'MW', 'MX',
+    'MY', 'MZ', 'NA', 'NC', 'NE', 'NF', 'NG', 'NI', 'NL', 'NO', 'NP', 'NR', 'NU', 'NZ', 'OM', 'PA', 'PE', 'PF', 'PG', 'PH', 'PK', 'PL', 'PM',
+    'PN', 'PR', 'PS', 'PT', 'PW', 'PY', 'QA', 'RE', 'RO', 'RU', 'RW', 'SA', 'SB', 'SC', 'SD', 'SE', 'SG', 'SH', 'SI', 'SJ', 'SK', 'SL', 'SM',
+    'SN', 'SO', 'SR', 'ST', 'SV', 'SY', 'SZ', 'TC', 'TD', 'TF', 'TG', 'TH', 'TJ', 'TK', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV', 'TW', 'TZ',
+    'UA', 'UG', 'UM', 'US', 'UY', 'UZ', 'VA', 'VC', 'VE', 'VG', 'VI', 'VN', 'VU', 'WF', 'WS', 'YE', 'YT', 'ZA', 'ZM', 'ZW'];

package/dist/literal/environment.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Environment items
+ * */
+export declare const EnvironmentItems: readonly ["automation", "development", "local", "production", "staging", "test"];
+/**
+ * Environment
+ * */
+export type Environment = typeof EnvironmentItems[number];

package/dist/literal/environment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentItems = void 0;
+/**
+ * Environment items
+ * */
+exports.EnvironmentItems = ['automation', 'development', 'local', 'production', 'staging', 'test'];

package/dist/literal/http-method.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Http Method items
+ * */
+export declare const HttpMethodItems: readonly ["delete", "get", "head", "link", "options", "patch", "post", "purge", "put", "unlink"];
+/**
+ * Http Method
+ * */
+export type HttpMethod = typeof HttpMethodItems[number];

package/dist/literal/http-method.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethodItems = void 0;
+/**
+ * Http Method items
+ * */
+exports.HttpMethodItems = ['delete', 'get', 'head', 'link', 'options', 'patch', 'post', 'purge', 'put', 'unlink'];

package/dist/literal/http-place.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Http Place items
+ * */
+export declare const HttpPlaceItems: readonly ["query", "body", "header", "path"];
+/**
+ * Http Place
+ * */
+export type HttpPlace = typeof HttpPlaceItems[number];

package/dist/literal/http-place.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpPlaceItems = void 0;
+/**
+ * Http Place items
+ * */
+exports.HttpPlaceItems = ['query', 'body', 'header', 'path'];

package/dist/literal/index-types.d.ts

@@ -0,0 +1,6 @@
+import { WeakTrue } from "./weak-true";
+import { WeakFalse } from "./weak-false";
+/**
+ * Weak Boolean
+ * */
+export type WeakBoolean = WeakTrue & WeakFalse;

package/dist/literal/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/literal/index.d.ts

@@ -0,0 +1,16 @@
+export * from './country-code';
+export * from './environment';
+export * from './http-method';
+export * from './http-place';
+export * from './key-value';
+export * from './language-code';
+export * from './locale-code';
+export * from './primitive';
+export * from './real-value';
+export * from './severity';
+export * from './storage-type';
+export * from './sys-class';
+export * from './sys-function';
+export * from './weak-false';
+export * from './weak-true';
+export * from './index-types';

package/dist/literal/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./country-code"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./http-method"), exports);
+__exportStar(require("./http-place"), exports);
+__exportStar(require("./key-value"), exports);
+__exportStar(require("./language-code"), exports);
+__exportStar(require("./locale-code"), exports);
+__exportStar(require("./primitive"), exports);
+__exportStar(require("./real-value"), exports);
+__exportStar(require("./severity"), exports);
+__exportStar(require("./storage-type"), exports);
+__exportStar(require("./sys-class"), exports);
+__exportStar(require("./sys-function"), exports);
+__exportStar(require("./weak-false"), exports);
+__exportStar(require("./weak-true"), exports);
+__exportStar(require("./index-types"), exports);

package/dist/literal/key-value.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Key Value items
+ * */
+export declare const KeyValueItems: readonly ["string", "number"];