jalhyd/build/props.js

JaLHyd, a Javascript Library for Hydraulics

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Props = exports.Prop_NullParameters = exports.enumValueFromString = void 0;
const lodash_1 = require("lodash");
const internal_modules_1 = require("./internal_modules");
/**
 * get enum numerical value from enum class name and value as a string
 * @param enumClass enum class name
 * @param enumValueName enum value as a string
 * @returns enum numerical value
 */
function enumValueFromString(enumClass, enumValueName) {
    // !! property names must be unique throughout JaLHyd !!
    const enumValues = Props.enumFromProperty[enumClass];
    if (enumValues) {
        return enumValues[enumValueName];
    }
    throw new Error("unknown enum class ${enumClass}");
}
exports.enumValueFromString = enumValueFromString;
/**
 * represents a boolean: true if provided value at parameter creation must be ignore (@see nghyd/enableEmptyFieldsOnFormInit)
 */
exports.Prop_NullParameters = "nullparams";
/**
 * gestion d'un ensemble de propriétés (clé/valeur) qui prévient quand
 * l'une d'entre-elles change
 */
class Props {
    constructor(prps) {
        // object literal representing properties keys and values
        this._map = {};
        this._observable = new internal_modules_1.Observable();
        if (prps !== undefined) {
            if (Props.implementsIProperties(prps)) {
                this.copyIProperties(prps);
            }
            else
                this._map = (0, lodash_1.cloneDeep)(prps);
        }
    }
    /**
     * @returns true if an object implements the IProperties interface
     */
    static implementsIProperties(o) {
        return "getPropValue" in o && "setPropValue" in o && "hasProperty" in o && "keys" in o;
    }
    /**
     * set properties map from an IProperties
     */
    copyIProperties(p) {
        this._map = {};
        for (const k of p.keys) {
            this._map[k] = p.getPropValue(k);
        }
    }
    get keys() {
        return Object.keys(this._map);
    }
    getPropValue(key) {
        return this._map[key];
    }
    setPropValue(key, val, sender) {
        if (key === undefined) {
            throw new Error("setPropValue : undefined key!");
        }
        const oldValue = this._map[key];
        const changed = oldValue !== val;
        if (changed) {
            this._map[key] = val;
            this.notifyPropChange(key, val, sender);
        }
        return changed;
    }
    removeProp(key) {
        delete this._map[key];
    }
    hasProperty(key) {
        return true;
    }
    getObservers() {
        return this._observable.getObservers();
    }
    /**
     * Remove all properties, does not notify of any change
     */
    reset() {
        this._map = {};
    }
    /**
     * Clones properties into a new Props object
     */
    clone() {
        return new Props(this);
    }
    toString() {
        let res = "[";
        for (const k in this._map) {
            if (this._map.hasOwnProperty(k)) {
                if (res !== "[") {
                    res += ", ";
                }
                res += `${k}:${this._map[k]}`;
            }
        }
        res += "]";
        return res;
    }
    // interface IObservable
    /**
     * ajoute un observateur à la liste
     */
    addObserver(o) {
        this._observable.addObserver(o);
    }
    /**
     * supprime un observateur de la liste
     */
    removeObserver(o) {
        this._observable.removeObserver(o);
    }
    /**
     * notifie un événement aux observateurs
     */
    notifyObservers(data, sender) {
        this._observable.notifyObservers(data, sender);
    }
    /**
     * notification de changement de la valeur d'une propriété
     * @param prop nom de la propriété modifiée
     * @param val nouvelle valeur
     * @param sender objet ayant changé la valeur
     */
    notifyPropChange(prop, val, sender) {
        this.notifyObservers({
            action: "propertyChange",
            name: prop,
            value: val
        }, sender);
    }
    /**
     * Returns a copy of given map, inverting enum keys and values
     */
    static invertEnumKeysAndValuesInProperties(stringProps, forceNumbers = false) {
        const res = JSON.parse(JSON.stringify(stringProps)); // clone
        for (const k in res) {
            if (!forceNumbers || !(0, internal_modules_1.isNumeric)(res[k])) {
                if (Object.keys(Props.enumFromProperty).includes(k)) {
                    const enumClass = Props.enumFromProperty[k];
                    res[k] = enumClass[res[k]];
                }
            }
        }
        return res;
    }
    invertEnumKeysAndValues(forceNumbers = false) {
        return Props.invertEnumKeysAndValuesInProperties(this._map, forceNumbers);
    }
}
exports.Props = Props;
/** correspondance entre les noms de propriétés et les enum associés */
Props.enumFromProperty = {
    calcType: internal_modules_1.CalculatorType,
    divingJetSupported: internal_modules_1.DivingJetSupport,
    gridProfile: internal_modules_1.GrilleProfile,
    gridType: internal_modules_1.GrilleType,
    inclinedApron: internal_modules_1.MRCInclination,
    loiDebit: internal_modules_1.LoiDebit,
    material: internal_modules_1.LCMaterial,
    methodeResolution: internal_modules_1.MethodeResolution,
    nodeType: internal_modules_1.SectionType,
    parType: internal_modules_1.ParType,
    pressureLossType: internal_modules_1.PressureLossType,
    regime: internal_modules_1.BiefRegime,
    species: internal_modules_1.FishSpecies,
    sppOperation: internal_modules_1.SPPOperation,
    structureType: internal_modules_1.StructureType,
    trigoOperation: internal_modules_1.TrigoOperation,
    trigoUnit: internal_modules_1.TrigoUnit,
    rugofondType: internal_modules_1.RugofondType
};
//# sourceMappingURL=props.js.map