@magmacomputing/tempo 1.0.0 → 1.0.1

package/dist/cipher.class.js

@@ -1,3 +1,46 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 import { toHex } from './number.library.js';
 import { asString } from './string.library.js';
 import { Immutable, Static } from './class.library.js';
@@ -12,54 +55,78 @@ const keys = {
     TypeKey: 'AES-GCM',
 };
 /** Static-only cryptographic methods */
-@Immutable
-@Static // prevent instantiation
-export class Cipher {
-    static #cryptoKey = subtle.generateKey({ name: keys.TypeKey, length: 128 }, false, ['encrypt', 'decrypt']);
-    static #vector = crypto.getRandomValues(new Uint8Array(16));
-    static #asymmetricKey = subtle.generateKey({
-        name: keys.SignKey,
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: { name: keys.Algorithm },
-    }, false, ['sign', 'verify']);
-    /** random UUID */
-    static randomKey = () => crypto.randomUUID().split('-')[0];
-    /** decode base64 back into object */
-    static decodeBase64 = (buf = '') => {
-        const uint8 = base64DecToArr(buf); // first, convert to UInt8Array
-        const str = UTF8ArrToStr(uint8); // convert to string
-        return objectify(str); // rebuild the original object
-    };
-    /** encode object into base64 */
-    static encodeBase64 = (buf) => {
-        const str = stringify(buf); // first, stringify the incoming buffer
-        const uint8 = strToUTF8Arr(str); // convert to Uint8Array
-        return base64EncArr(uint8); // convert to string
-    };
-    static hmac = async (source, secret, alg = 'SHA-512', len) => {
-        const encoder = new TextEncoder();
-        const keyData = encoder.encode(secret);
-        const messageData = encoder.encode(asString(source));
-        const key = await subtle.importKey('raw', keyData, { name: 'HMAC', hash: { name: alg } }, false, ['sign']);
-        const signature = await subtle.sign('HMAC', key, messageData);
-        return toHex(Array.from(new Uint8Array(signature)), len);
-    };
-    static hash = async (source, len, alg = 'SHA-256') => {
-        const buffer = Cipher.encodeBuffer(asString(source));
-        const hash = await subtle.digest(alg, buffer);
-        return toHex(Array.from(new Uint8Array(hash)), len);
+let Cipher = (() => {
+    var _Cipher_cryptoKey, _Cipher_vector, _Cipher_asymmetricKey;
+    let _classDecorators = [Immutable, Static];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Cipher = class {
+        static { _classThis = this; }
+        static { __setFunctionName(this, "Cipher"); }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Cipher = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static {
+            _Cipher_cryptoKey = { value: subtle.generateKey({ name: keys.TypeKey, length: 128 }, false, ['encrypt', 'decrypt']) };
+        }
+        static {
+            _Cipher_vector = { value: crypto.getRandomValues(new Uint8Array(16)) };
+        }
+        static {
+            _Cipher_asymmetricKey = { value: subtle.generateKey({
+                    name: keys.SignKey,
+                    modulusLength: 2048,
+                    publicExponent: new Uint8Array([1, 0, 1]),
+                    hash: { name: keys.Algorithm },
+                }, false, ['sign', 'verify']) };
+        }
+        /** random UUID */
+        static randomKey = () => crypto.randomUUID().split('-')[0];
+        /** decode base64 back into object */
+        static decodeBase64 = (buf = '') => {
+            const uint8 = base64DecToArr(buf); // first, convert to UInt8Array
+            const str = UTF8ArrToStr(uint8); // convert to string
+            return objectify(str); // rebuild the original object
+        };
+        /** encode object into base64 */
+        static encodeBase64 = (buf) => {
+            const str = stringify(buf); // first, stringify the incoming buffer
+            const uint8 = strToUTF8Arr(str); // convert to Uint8Array
+            return base64EncArr(uint8); // convert to string
+        };
+        static hmac = async (source, secret, alg = 'SHA-512', len) => {
+            const encoder = new TextEncoder();
+            const keyData = encoder.encode(secret);
+            const messageData = encoder.encode(asString(source));
+            const key = await subtle.importKey('raw', keyData, { name: 'HMAC', hash: { name: alg } }, false, ['sign']);
+            const signature = await subtle.sign('HMAC', key, messageData);
+            return toHex(Array.from(new Uint8Array(signature)), len);
+        };
+        static hash = async (source, len, alg = 'SHA-256') => {
+            const buffer = Cipher.encodeBuffer(asString(source));
+            const hash = await subtle.digest(alg, buffer);
+            return toHex(Array.from(new Uint8Array(hash)), len);
+        };
+        static encodeBuffer = (str) => new Uint16Array(new TextEncoder().encode(str));
+        static decodeBuffer = (buf) => new TextDecoder(keys.Encoding).decode(buf);
+        static encrypt = async (data) => subtle.encrypt({ name: keys.TypeKey, iv: __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_vector) }, await __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_cryptoKey), Cipher.encodeBuffer(data))
+            .then(result => new Uint16Array(result))
+            .then(Cipher.decodeBuffer);
+        static decrypt = async (secret) => subtle.decrypt({ name: keys.TypeKey, iv: __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_vector) }, await __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_cryptoKey), await secret)
+            .then(result => new Uint16Array(result))
+            .then(Cipher.decodeBuffer);
+        static sign = async (doc) => subtle.sign(keys.SignKey, (await __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_asymmetricKey)).privateKey, Cipher.encodeBuffer(doc))
+            .then(result => new Uint16Array(result))
+            .then(Cipher.decodeBuffer);
+        static verify = async (signature, doc) => subtle.verify(keys.SignKey, (await __classPrivateFieldGet(Cipher, _classThis, "f", _Cipher_asymmetricKey)).publicKey, await signature, Cipher.encodeBuffer(doc));
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
-    static encodeBuffer = (str) => new Uint16Array(new TextEncoder().encode(str));
-    static decodeBuffer = (buf) => new TextDecoder(keys.Encoding).decode(buf);
-    static encrypt = async (data) => subtle.encrypt({ name: keys.TypeKey, iv: Cipher.#vector }, await Cipher.#cryptoKey, Cipher.encodeBuffer(data))
-        .then(result => new Uint16Array(result))
-        .then(Cipher.decodeBuffer);
-    static decrypt = async (secret) => subtle.decrypt({ name: keys.TypeKey, iv: Cipher.#vector }, await Cipher.#cryptoKey, await secret)
-        .then(result => new Uint16Array(result))
-        .then(Cipher.decodeBuffer);
-    static sign = async (doc) => subtle.sign(keys.SignKey, (await Cipher.#asymmetricKey).privateKey, Cipher.encodeBuffer(doc))
-        .then(result => new Uint16Array(result))
-        .then(Cipher.decodeBuffer);
-    static verify = async (signature, doc) => subtle.verify(keys.SignKey, (await Cipher.#asymmetricKey).publicKey, await signature, Cipher.encodeBuffer(doc));
-}
+    return Cipher = _classThis;
+})();
+export { Cipher };

package/dist/enumerate.library.js

@@ -1,3 +1,37 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { secure } from './utility.library.js';
 import { Serializable } from './class.library.js';
 import { stringify } from './serialize.library.js';
@@ -46,9 +80,24 @@ export function enumify(list) {
     return secure(Object.create(ENUM, Object.getOwnPropertyDescriptors(stash)));
 }
 /** create an entry in the Serialization Registry to describe how to rebuild an Enum */
-@Serializable
-export class Enumify {
-    constructor(list) {
-        return enumify(list);
-    }
-}
+let Enumify = (() => {
+    let _classDecorators = [Serializable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Enumify = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Enumify = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(list) {
+            return enumify(list);
+        }
+    };
+    return Enumify = _classThis;
+})();
+export { Enumify };

package/dist/index.d.ts

@@ -1 +1,2 @@
+import './temporal.polyfill.js';
 export { Tempo } from './tempo.class.js';

package/dist/index.js

@@ -1,3 +1,2 @@
+import './temporal.polyfill.js';
 export { Tempo } from './tempo.class.js';
-// Add any other intended public exports here. 
-// For now, Tempo is the primary interface.

package/dist/logify.class.js

@@ -1,3 +1,37 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { Immutable } from './class.library.js';
 import { asType } from './type.library.js';
 const Method = {
@@ -10,44 +44,59 @@ const Method = {
 /**
  * provide standard logging methods to the console for a class
  */
-@Immutable
-export class Logify {
-    #name;
-    #opts = {};
-    #log(method, ...msg) {
-        if (this.#opts.debug)
-            console[method](this.#name, ...msg);
-    }
-    /**
-     * if {catch:true} then show a warning on the console and return
-     * otherwise show an error on the console and re-throw the error
-     */
-    catch(...msg) {
-        if (this.#opts.catch) {
-            this.warn(...msg); // show a warning on the console
-            return; // safe-return
+let Logify = (() => {
+    let _classDecorators = [Immutable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Logify = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Logify = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        this.error(...msg); // this goes to the console
-        throw new Error(`${this.#name}${msg}`); // this goes back to the caller
-    }
-    /** console.log */ log = this.#log.bind(this, Method.Log);
-    /** console.info */ info = this.#log.bind(this, Method.Info);
-    /** console.warn */ warn = this.#log.bind(this, Method.Warn);
-    /** console.debug */ debug = this.#log.bind(this, Method.Debug);
-    /** console.error */ error = this.#log.bind(this, Method.Error);
-    constructor(self, opts = {}) {
-        const arg = asType(self);
-        switch (arg.type) {
-            case 'String':
-                this.#name = arg.value;
-                break;
-            // @ts-ignore
-            case 'Object':
-                Object.assign(opts, arg.value);
-            default:
-                this.#name = (self ?? this).constructor.name.concat(': ') ?? '';
+        #name;
+        #opts = {};
+        #log(method, ...msg) {
+            if (this.#opts.debug)
+                console[method](this.#name, ...msg);
         }
-        this.#opts.debug = opts.debug ?? false; // default debug to 'false'
-        this.#opts.catch = opts.catch ?? false; // default catch to 'false'								
-    }
-}
+        /**
+         * if {catch:true} then show a warning on the console and return
+         * otherwise show an error on the console and re-throw the error
+         */
+        catch(...msg) {
+            if (this.#opts.catch) {
+                this.warn(...msg); // show a warning on the console
+                return; // safe-return
+            }
+            this.error(...msg); // this goes to the console
+            throw new Error(`${this.#name}${msg}`); // this goes back to the caller
+        }
+        /** console.log */ log = this.#log.bind(this, Method.Log);
+        /** console.info */ info = this.#log.bind(this, Method.Info);
+        /** console.warn */ warn = this.#log.bind(this, Method.Warn);
+        /** console.debug */ debug = this.#log.bind(this, Method.Debug);
+        /** console.error */ error = this.#log.bind(this, Method.Error);
+        constructor(self, opts = {}) {
+            const arg = asType(self);
+            switch (arg.type) {
+                case 'String':
+                    this.#name = arg.value;
+                    break;
+                // @ts-ignore
+                case 'Object':
+                    Object.assign(opts, arg.value);
+                default:
+                    this.#name = (self ?? this).constructor.name.concat(': ') ?? '';
+            }
+            this.#opts.debug = opts.debug ?? false; // default debug to 'false'
+            this.#opts.catch = opts.catch ?? false; // default catch to 'false'								
+        }
+    };
+    return Logify = _classThis;
+})();
+export { Logify };