@magmacomputing/tempo 1.0.0 → 1.0.1

package/dist/pledge.class.js

@@ -1,3 +1,52 @@
+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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 { Logify } from './logify.class.js';
 import { asArray } from './array.library.js';
 import { sprintf } from './string.library.js';
@@ -14,118 +63,139 @@ import { isEmpty, isObject } from './type.library.js';
      new Pledge<T>(tag?: string)
  ```
  */
-@Immutable
-export class Pledge {
-    #pledge;
-    #status = {};
-    #dbg;
-    static #static = {};
-    static STATE = secure({
-        Pending: Symbol('pending'),
-        Resolved: Symbol('resolved'),
-        Rejected: Symbol('rejected')
-    });
-    /** initialize future Pledge instances */
-    static init(arg) {
-        if (isObject(arg)) {
-            if (isEmpty(arg))
-                Pledge.#static = {}; // reset static values
-            Object.assign(Pledge.#static, ifDefined({ tag: arg.tag, debug: arg.debug, catch: arg.catch, }), ifDefined({ onResolve: arg.onResolve, onReject: arg.onReject, onSettle: arg.onSettle, }));
-        }
-        else {
-            Object.assign(Pledge.#static, ifDefined({ tag: arg, }));
-        }
-        if (Pledge.#static.debug)
-            console.log('Pledge: ', Pledge.#static); // debug
-        return Pledge.status;
-    }
-    static get status() {
-        return Pledge.#static;
-    }
-    /** use catch:boolean to determine whether to throw or return  */
-    #catch(...msg) {
-        if (this.status.catch) {
-            this.#dbg.warn(...msg); // catch, but warn {error}
-            return;
-        }
-        this.#dbg.error(...msg); // assume {error}
-        throw new Error(sprintf('pledge: ', ...msg));
-    }
-    constructor(arg) {
-        this.#pledge = Promise.withResolvers();
-        this.#status = { state: Pledge.STATE.Pending, ...Pledge.#static };
-        if (isObject(arg)) {
-            this.#dbg = new Logify({ debug: arg.debug, catch: arg.catch });
-            Object.assign(this.#status, ifDefined({ tag: Pledge.#static.tag, debug: Pledge.#static.debug, catch: Pledge.#static.catch }), ifDefined({ tag: arg.tag, debug: arg.debug, catch: arg.catch, }));
-            asArray(Pledge.#static.onResolve) // stack any static onResolve actions
-                .concat(asArray(arg.onResolve)) // stack any instance onResolve actions
-                .forEach(resolve => this.#pledge.promise.then(resolve));
-            asArray(Pledge.#static.onReject) // stack any static onReject actions
-                .concat(asArray(arg.onReject)) // stack any instance onReject actions
-                .forEach(reject => this.#pledge.promise.catch(reject));
-            asArray(Pledge.#static.onSettle) // stack any static onSettle actions
-                .concat(asArray(arg.onSettle)) // stack any instance onSettle actions
-                .forEach(settle => this.#pledge.promise.finally(settle));
-            if (this.#status.catch) // stack a 'catch-all'
-                this.#pledge.promise.catch(_ => this.#catch(this.#status, this.#status.error));
-        }
-        else {
-            this.#dbg = new Logify();
-            Object.assign(this.#status, ifDefined({ tag: arg ?? Pledge.#static.tag, }));
-        }
-        Object.freeze(this); // make this instance immutable
-    }
-    get [Symbol.toStringTag]() {
-        return 'Pledge';
-    }
-    [Symbol.dispose]() {
-        if (this.isPending)
-            this.reject(new Error(`Pledge disposed`)); // discard pending Pledge (to notify wait-ers)
-    }
-    get status() {
-        return cleanify(this.#status);
-    }
-    get promise() {
-        return this.#pledge.promise;
-    }
-    get state() {
-        return this.#status.state.description;
-    }
-    get isPending() {
-        return this.#status.state === Pledge.STATE.Pending;
-    }
-    get isResolved() {
-        return this.#status.state === Pledge.STATE.Resolved;
-    }
-    get isRejected() {
-        return this.#status.state === Pledge.STATE.Rejected;
-    }
-    get isSettled() {
-        return this.#status.state !== Pledge.STATE.Pending;
-    }
-    toString() {
-        return JSON.stringify(this.status);
-    }
-    resolve(value) {
-        if (this.isPending) {
-            this.#status.settled = value;
-            this.#status.state = Pledge.STATE.Resolved;
-            this.#pledge.resolve(value); // resolve, then trigger any Pledge.onResolve, then Pledge.onSettle
-        }
-        else
-            this.#dbg.warn(this.#status, `Pledge was already ${this.state}`);
-        return this.#pledge.promise;
-    }
-    reject(error) {
-        if (this.isPending) {
-            this.#status.error = error;
-            this.#status.state = Pledge.STATE.Rejected;
-            this.#pledge.reject(error); // reject, then trigger any Pledge.onReject, then Pledge.onSettle
-        }
-        else
-            this.#dbg.warn(this.#status, `Pledge was already ${this.state}`);
-        return this.#pledge.promise;
-    }
-    then(fn) {
-    }
-}
+let Pledge = (() => {
+    var _Pledge_static;
+    let _classDecorators = [Immutable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Pledge = class {
+        static { _classThis = this; }
+        static { __setFunctionName(this, "Pledge"); }
+        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);
+            Pledge = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #pledge;
+        #status = {};
+        #dbg;
+        static {
+            _Pledge_static = { value: {} };
+        }
+        static STATE = secure({
+            Pending: Symbol('pending'),
+            Resolved: Symbol('resolved'),
+            Rejected: Symbol('rejected')
+        });
+        /** initialize future Pledge instances */
+        static init(arg) {
+            if (isObject(arg)) {
+                if (isEmpty(arg))
+                    __classPrivateFieldSet(Pledge, _classThis, {}, "f", _Pledge_static); // reset static values
+                Object.assign(__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static), ifDefined({ tag: arg.tag, debug: arg.debug, catch: arg.catch, }), ifDefined({ onResolve: arg.onResolve, onReject: arg.onReject, onSettle: arg.onSettle, }));
+            }
+            else {
+                Object.assign(__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static), ifDefined({ tag: arg, }));
+            }
+            if (__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).debug)
+                console.log('Pledge: ', __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static)); // debug
+            return Pledge.status;
+        }
+        static get status() {
+            return __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static);
+        }
+        /** use catch:boolean to determine whether to throw or return  */
+        #catch(...msg) {
+            if (this.status.catch) {
+                this.#dbg.warn(...msg); // catch, but warn {error}
+                return;
+            }
+            this.#dbg.error(...msg); // assume {error}
+            throw new Error(sprintf('pledge: ', ...msg));
+        }
+        constructor(arg) {
+            this.#pledge = Promise.withResolvers();
+            this.#status = { state: Pledge.STATE.Pending, ...__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static) };
+            if (isObject(arg)) {
+                this.#dbg = new Logify({ debug: arg.debug, catch: arg.catch });
+                Object.assign(this.#status, ifDefined({ tag: __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).tag, debug: __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).debug, catch: __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).catch }), ifDefined({ tag: arg.tag, debug: arg.debug, catch: arg.catch, }));
+                asArray(__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).onResolve) // stack any static onResolve actions
+                    .concat(asArray(arg.onResolve)) // stack any instance onResolve actions
+                    .forEach(resolve => this.#pledge.promise.then(resolve));
+                asArray(__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).onReject) // stack any static onReject actions
+                    .concat(asArray(arg.onReject)) // stack any instance onReject actions
+                    .forEach(reject => this.#pledge.promise.catch(reject));
+                asArray(__classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).onSettle) // stack any static onSettle actions
+                    .concat(asArray(arg.onSettle)) // stack any instance onSettle actions
+                    .forEach(settle => this.#pledge.promise.finally(settle));
+                if (this.#status.catch) // stack a 'catch-all'
+                    this.#pledge.promise.catch(_ => this.#catch(this.#status, this.#status.error));
+            }
+            else {
+                this.#dbg = new Logify();
+                Object.assign(this.#status, ifDefined({ tag: arg ?? __classPrivateFieldGet(Pledge, _classThis, "f", _Pledge_static).tag, }));
+            }
+            Object.freeze(this); // make this instance immutable
+        }
+        get [Symbol.toStringTag]() {
+            return 'Pledge';
+        }
+        [Symbol.dispose]() {
+            if (this.isPending)
+                this.reject(new Error(`Pledge disposed`)); // discard pending Pledge (to notify wait-ers)
+        }
+        get status() {
+            return cleanify(this.#status);
+        }
+        get promise() {
+            return this.#pledge.promise;
+        }
+        get state() {
+            return this.#status.state.description;
+        }
+        get isPending() {
+            return this.#status.state === Pledge.STATE.Pending;
+        }
+        get isResolved() {
+            return this.#status.state === Pledge.STATE.Resolved;
+        }
+        get isRejected() {
+            return this.#status.state === Pledge.STATE.Rejected;
+        }
+        get isSettled() {
+            return this.#status.state !== Pledge.STATE.Pending;
+        }
+        toString() {
+            return JSON.stringify(this.status);
+        }
+        resolve(value) {
+            if (this.isPending) {
+                this.#status.settled = value;
+                this.#status.state = Pledge.STATE.Resolved;
+                this.#pledge.resolve(value); // resolve, then trigger any Pledge.onResolve, then Pledge.onSettle
+            }
+            else
+                this.#dbg.warn(this.#status, `Pledge was already ${this.state}`);
+            return this.#pledge.promise;
+        }
+        reject(error) {
+            if (this.isPending) {
+                this.#status.error = error;
+                this.#status.state = Pledge.STATE.Rejected;
+                this.#pledge.reject(error); // reject, then trigger any Pledge.onReject, then Pledge.onSettle
+            }
+            else
+                this.#dbg.warn(this.#status, `Pledge was already ${this.state}`);
+            return this.#pledge.promise;
+        }
+        then(fn) {
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Pledge = _classThis;
+})();
+export { Pledge };

package/dist/tempo.class.d.ts

@@ -1,3 +1,4 @@
+import './temporal.polyfill.js';
 import type { IntRange, LiteralKey, LooseUnion, NonOptional, Property, Type } from './type.library.js';
 import * as enums from './tempo.config/tempo.enum.js';
 import { Token, Snippet, Layout, Event, Period } from './tempo.config/tempo.default.js';