@naturalcycles/js-lib/dist/define.js

Standard library for universal (browser + Node.js) javascript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports._lazyValue = _lazyValue;
exports._defineLazyProperty = _defineLazyProperty;
exports._defineLazyProps = _defineLazyProps;
exports._defineProperty = _defineProperty;
exports._defineProps = _defineProps;
exports._defineNonNullishProps = _defineNonNullishProps;
const object_util_1 = require("./object/object.util");
const types_1 = require("./types");
/**
 * const value = lazyValue(() => expensiveComputation())
 *
 * value() // calls expensiveComputation() once
 * value() // returns cached result
 * value() // returns cached result
 *
 * Based on: https://github.com/sindresorhus/lazy-value
 */
function _lazyValue(fn) {
    let isCalled = false;
    let result;
    return (() => {
        if (!isCalled) {
            isCalled = true;
            result = fn();
        }
        return result;
    });
}
/**
 * interface Obj {
 *   v: number
 * }
 *
 * const obj = {} as Obj
 *
 * _defineLazyProperty(obj, 'v', () => expensiveComputation())
 * obj.v // runs expensiveComputation() once
 * obj.v // cached value
 * obj.v // cached value
 *
 * Based on: https://github.com/sindresorhus/define-lazy-prop
 */
function _defineLazyProperty(obj, propertyName, fn) {
    const define = (value) => {
        Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true });
    };
    Object.defineProperty(obj, propertyName, {
        configurable: true,
        enumerable: true,
        get() {
            const result = fn();
            define(result);
            return result;
        },
        set(value) {
            define(value);
        },
    });
    return obj;
}
/**
 * Like _defineLazyProperty, but allows to define multiple props at once.
 */
function _defineLazyProps(obj, props) {
    Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn));
    return obj;
}
/**
 * Same as Object.defineProperty, but with better (least restricting) defaults.
 *
 * Defaults are:
 * writable: true
 * configurable: true
 * enumerable: true
 * value: existing obj[prop] value
 *
 * Original defaults:
 * writable: false
 * configurable: false
 * enumerable: false
 * value: existing obj[prop] value
 *
 */
function _defineProperty(obj, prop, pd) {
    return Object.defineProperty(obj, prop, {
        writable: true,
        configurable: true,
        enumerable: true,
        // value: obj[prop], // existing value is already kept by default
        ...pd,
    });
}
/**
 * Object.defineProperties with better defaults.
 * See _defineProperty for exact defaults definition.
 */
function _defineProps(obj, props) {
    return Object.defineProperties(obj, (0, object_util_1._mapValues)(props, (_k, pd) => ({
        writable: true,
        configurable: true,
        enumerable: true,
        // value: obj[k], // existing value is already kept by default
        ...pd,
    })));
}
/**
 * Like _defineProps, but skips props with nullish values.
 */
function _defineNonNullishProps(obj, props) {
    return _defineProps(obj, (0, object_util_1._mapObject)(props, (k, pd) => {
        if (pd.value === null || pd.value === undefined)
            return types_1.SKIP;
        return [k, pd];
    }));
}