@blinkk/selective-edit/dist/selective/autoFields.js

Selective structured text editor.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.guessLabel = exports.AutoFields = void 0;
const dataType_1 = require("../utility/dataType");
class AutoFields {
    constructor(config) {
        this.config = config || {};
    }
    deepGuess(data, keyBase) {
        keyBase = keyBase || [];
        if (dataType_1.DataType.isArray(data)) {
            return this.deepGuessArray(data, keyBase);
        }
        // Object are guessed based on keys.
        if (dataType_1.DataType.isObject(data)) {
            return this.deepGuessObject(data, keyBase);
        }
        // Default to guessing as a single field.
        return [this.guessField(keyBase.join('.'), data)];
    }
    deepGuessArray(data, keyBase) {
        keyBase = keyBase || [];
        if (!data.length) {
            return [];
        }
        // Handle arrays by guessing for first element.
        return this.deepGuess(data[0], keyBase);
    }
    deepGuessObject(data, keyBase) {
        let fieldConfigs = [];
        keyBase = keyBase || [];
        for (const key of Object.keys(data)) {
            // Skip ignored keys.
            if (this.isIgnoredKey(key)) {
                continue;
            }
            const newKeyBase = keyBase.concat([key]);
            const newData = data[key];
            if (dataType_1.DataType.isObject(newData)) {
                fieldConfigs = fieldConfigs.concat(this.deepGuessObject(newData, newKeyBase));
            }
            else {
                fieldConfigs.push(this.deepGuessSimple(data[key], newKeyBase));
            }
        }
        return fieldConfigs;
    }
    deepGuessSimple(data, keyBase) {
        keyBase = keyBase || [];
        const fullKey = keyBase.join('.');
        return this.guessField(fullKey, data);
    }
    guessField(key, data) {
        const fieldType = this.guessType(key, data);
        const label = guessLabel(key);
        const fieldConfig = {
            key: key,
            type: fieldType,
        };
        if (label !== '') {
            fieldConfig.label = label;
        }
        if (fieldType === 'list') {
            fieldConfig.fields = this.deepGuess(data);
        }
        return fieldConfig;
    }
    guessFields(data) {
        return this.deepGuess(data);
    }
    /**
     * Guess the type of field to use based on the key and value.
     *
     * @param key Key to guess the type of field.
     * @param data Data to use for guessing field type.
     */
    guessType(key, data) {
        if (dataType_1.DataType.isNull(data) || dataType_1.DataType.isUndefined(data)) {
            return 'text';
        }
        if (dataType_1.DataType.isArray(data)) {
            return 'list';
        }
        if (dataType_1.DataType.isString(data) && data.length > 75) {
            return 'textarea';
        }
        return 'text';
    }
    isIgnoredKey(key) {
        // Ignore keys based on patterns or a set of keys.
        const ignorePatterns = this.config.ignorePatterns || [];
        const ignoreKeys = this.config.ignoreKeys || [];
        // Test for the ignored keys.
        if (ignoreKeys.includes(key)) {
            return true;
        }
        // Test for the ignored patterns.
        for (const ignorePattern of ignorePatterns) {
            const ignoreRegex = new RegExp(ignorePattern);
            if (ignoreRegex.test(key)) {
                return true;
            }
        }
        return false;
    }
}
exports.AutoFields = AutoFields;
/**
 * From the key guess the label of the field.
 *
 * ex: key.subKey => Key SubKey
 */
function guessLabel(key) {
    key = key.replace(/\./g, ' ');
    key = key.replace(/-/g, ' ');
    key = key.replace(/_/g, ' ');
    return key
        .split(' ')
        .map(word => {
        return word.charAt(0).toUpperCase() + word.slice(1);
    })
        .join(' ');
}
exports.guessLabel = guessLabel;
//# sourceMappingURL=autoFields.js.map