namefully 1.2.0 → 1.3.0

package/dist/lib/builder.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameBuilder = void 0;
+const namefully_1 = require("./namefully");
+const validator_1 = require("./validator");
+class Builder {
+    constructor(prebuild, postbuild, preclear, postclear) {
+        this.prebuild = prebuild;
+        this.postbuild = postbuild;
+        this.preclear = preclear;
+        this.postclear = postclear;
+        this.queue = [];
+        this.instance = null;
+    }
+    get size() {
+        return this.queue.length;
+    }
+    removeFirst() {
+        return this.queue.length > 0 ? this.queue.shift() : undefined;
+    }
+    removeLast() {
+        return this.queue.length > 0 ? this.queue.pop() : undefined;
+    }
+    addFirst(value) {
+        this.queue.unshift(value);
+    }
+    addLast(value) {
+        this.queue.push(value);
+    }
+    add(...values) {
+        this.queue.push(...values);
+    }
+    remove(value) {
+        const index = this.queue.indexOf(value);
+        if (index !== -1) {
+            this.queue.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    removeWhere(callback) {
+        this.queue = this.queue.filter((item) => !callback(item));
+    }
+    retainWhere(callback) {
+        this.queue = this.queue.filter(callback);
+    }
+    clear() {
+        var _a, _b;
+        if (this.instance !== null)
+            (_a = this.preclear) === null || _a === void 0 ? void 0 : _a.call(this, this.instance);
+        this.queue = [];
+        (_b = this.postclear) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.instance = null;
+    }
+}
+class NameBuilder extends Builder {
+    constructor(names, prebuild, postbuild, preclear, postclear) {
+        super(prebuild, postbuild, preclear, postclear);
+        this.add(...names);
+    }
+    static create(name) {
+        return new NameBuilder(name ? [name] : []);
+    }
+    static of(...initialNames) {
+        return new NameBuilder(initialNames);
+    }
+    static use({ names, prebuild, postbuild, preclear, postclear, }) {
+        return new NameBuilder(names !== null && names !== void 0 ? names : [], prebuild, postbuild, preclear, postclear);
+    }
+    build(config) {
+        var _a, _b;
+        (_a = this.prebuild) === null || _a === void 0 ? void 0 : _a.call(this);
+        const names = [...this.queue];
+        validator_1.ArrayNameValidator.create().validate(names);
+        this.instance = new namefully_1.Namefully(names, config);
+        (_b = this.postbuild) === null || _b === void 0 ? void 0 : _b.call(this, this.instance);
+        return this.instance;
+    }
+}
+exports.NameBuilder = NameBuilder;

package/dist/lib/config.js

@@ -1,189 +1,112 @@
 "use strict";
+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);
+};
+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 _Config_instances, _a, _Config_name, _Config_orderedBy, _Config_separator, _Config_title, _Config_ending, _Config_bypass, _Config_surname, _Config_genNewName;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
 const types_1 = require("./types");
 const defaultName = 'default';
 const copyAlias = '_copy';
-/**
- * The Configuration to use across the other components.
- *
- * The multiton pattern is used to handle configurations across the `namefully`
- * setup. This adds consistency when building other components such as `FirstName`,
- * `LastName`, or `Name` of distinct types that may be of particular shapes.
- *
- * For example, a person's `FullName` may appear by:
- * - NameOrder.FIRST_NAME: `Jon Snow` or
- * - NameOrder.LAST_NAME: `Snow Jon`.
- *
- * `Config` makes it easy to set up a specific configuration for `Namefully`
- * and reuse it through other instances or components along the way. If a new
- * `Config` is needed, a named configuration may be created. It is actually
- * advised to use named `Config.create(name)` instead as it may help mitigate issues
- * and avoid confusion and ambiguity in the future. Plus, a named configuration
- * explains its purpose.
- *
- * ```ts
- * const defaultConfig = Config.create();
- * const mergedConfig = Config.merge({ name: 'other', title: Title.US });
- * const copyConfig = mergedConfig.copyWith({ ending: true });
- * ```
- *
- * Additionally, a configuration may be merged with or copied from an existing
- * configuration, prioritizing the new one's values, as shown in the example
- * above.
- */
 class Config {
-    constructor(name, orderedBy = types_1.NameOrder.FIRST_NAME, separator = types_1.Separator.SPACE, title = types_1.Title.UK, ending = false, bypass = true, surname = types_1.Surname.FATHER) {
-        this._name = name;
-        this._orderedBy = orderedBy;
-        this._separator = separator;
-        this._title = title;
-        this._ending = ending;
-        this._bypass = bypass;
-        this._surname = surname;
-    }
-    /**
-     * The order of appearance of a full name.
-     */
     get orderedBy() {
-        return this._orderedBy;
+        return __classPrivateFieldGet(this, _Config_orderedBy, "f");
     }
-    /**
-     * The token used to indicate how to split string values.
-     */
     get separator() {
-        return this._separator;
+        return __classPrivateFieldGet(this, _Config_separator, "f");
     }
-    /**
-     * The abbreviation type to indicate whether or not to add period to a prefix
-     * using the American or British way.
-     */
     get title() {
-        return this._title;
+        return __classPrivateFieldGet(this, _Config_title, "f");
     }
-    /**
-     * The option indicating if an ending suffix is used in a formal way.
-     */
     get ending() {
-        return this._ending;
+        return __classPrivateFieldGet(this, _Config_ending, "f");
     }
-    /**
-     * A bypass of the validation rules with this option. This option is ideal
-     * to avoid checking their validity.
-     */
     get bypass() {
-        return this._bypass;
+        return __classPrivateFieldGet(this, _Config_bypass, "f");
     }
-    /**
-     * An option indicating how to format a surname.
-     *
-     * The supported formats are:
-     * - `FATHER` name only
-     * - `MOTHER` name only
-     * - `HYPHENATED`, joining both father and mother names with a hyphen
-     * - `ALL`, joining both father and mother names with a space.
-     *
-     * Note that this option can be set when creating a `LastName`. As this can
-     * become ambiguous at the time of handling it, the value set in this is
-     * prioritized and viewed as the source of truth for future considerations.
-     */
     get surname() {
-        return this._surname;
+        return __classPrivateFieldGet(this, _Config_surname, "f");
     }
-    /**
-     * The name of the cached configuration.
-     */
     get name() {
-        return this._name;
+        return __classPrivateFieldGet(this, _Config_name, "f");
+    }
+    constructor(name, orderedBy = types_1.NameOrder.FIRST_NAME, separator = types_1.Separator.SPACE, title = types_1.Title.UK, ending = false, bypass = true, surname = types_1.Surname.FATHER) {
+        _Config_instances.add(this);
+        _Config_name.set(this, void 0);
+        _Config_orderedBy.set(this, void 0);
+        _Config_separator.set(this, void 0);
+        _Config_title.set(this, void 0);
+        _Config_ending.set(this, void 0);
+        _Config_bypass.set(this, void 0);
+        _Config_surname.set(this, void 0);
+        __classPrivateFieldSet(this, _Config_name, name, "f");
+        __classPrivateFieldSet(this, _Config_orderedBy, orderedBy, "f");
+        __classPrivateFieldSet(this, _Config_separator, separator, "f");
+        __classPrivateFieldSet(this, _Config_title, title, "f");
+        __classPrivateFieldSet(this, _Config_ending, ending, "f");
+        __classPrivateFieldSet(this, _Config_bypass, bypass, "f");
+        __classPrivateFieldSet(this, _Config_surname, surname, "f");
     }
-    /**
-     * Returns a named configuration with default values.
-     * @param name describing its purpose.
-     */
     static create(name = defaultName) {
-        if (!Config.cache.has(name)) {
-            Config.cache.set(name, new this(name));
-        }
-        return Config.cache.get(name);
+        if (!_a.cache.has(name))
+            _a.cache.set(name, new this(name));
+        return _a.cache.get(name);
     }
-    /**
-     * Returns a combined version of the existing values of the default configuration
-     * and the provided optional values of another configuration.
-     * @param other partial config to be combined with.
-     */
     static merge(other) {
-        var _a, _b, _c, _d, _e, _f;
+        var _b, _c, _d, _e, _f, _g;
         if (!other) {
-            return Config.create();
+            return _a.create();
         }
         else {
-            const config = Config.create(other.name);
-            config._orderedBy = (_a = other.orderedBy) !== null && _a !== void 0 ? _a : config.orderedBy;
-            config._separator = (_b = other.separator) !== null && _b !== void 0 ? _b : config.separator;
-            config._title = (_c = other.title) !== null && _c !== void 0 ? _c : config.title;
-            config._ending = (_d = other.ending) !== null && _d !== void 0 ? _d : config.ending;
-            config._bypass = (_e = other.bypass) !== null && _e !== void 0 ? _e : config.bypass;
-            config._surname = (_f = other.surname) !== null && _f !== void 0 ? _f : config.surname;
+            const config = _a.create(other.name);
+            __classPrivateFieldSet(config, _Config_orderedBy, (_b = other.orderedBy) !== null && _b !== void 0 ? _b : config.orderedBy, "f");
+            __classPrivateFieldSet(config, _Config_separator, (_c = other.separator) !== null && _c !== void 0 ? _c : config.separator, "f");
+            __classPrivateFieldSet(config, _Config_title, (_d = other.title) !== null && _d !== void 0 ? _d : config.title, "f");
+            __classPrivateFieldSet(config, _Config_ending, (_e = other.ending) !== null && _e !== void 0 ? _e : config.ending, "f");
+            __classPrivateFieldSet(config, _Config_bypass, (_f = other.bypass) !== null && _f !== void 0 ? _f : config.bypass, "f");
+            __classPrivateFieldSet(config, _Config_surname, (_g = other.surname) !== null && _g !== void 0 ? _g : config.surname, "f");
             return config;
         }
     }
-    /**
-     * Returns a copy of this configuration merged with the provided values.
-     *
-     * The word `_copy` is added to the existing config's name to create the new
-     * config's name if the name already exists for previous configurations. This
-     * is useful to maintain the uniqueness of each configuration. For example,
-     * if the new copy is made from the default configuration, this new copy will
-     * be named `default_copy`.
-     */
     copyWith(options = {}) {
         const { name, orderedBy, separator, title, ending, bypass, surname } = options;
-        const config = Config.create(this.genNewName(name !== null && name !== void 0 ? name : this.name + copyAlias));
-        config._orderedBy = orderedBy !== null && orderedBy !== void 0 ? orderedBy : this.orderedBy;
-        config._separator = separator !== null && separator !== void 0 ? separator : this.separator;
-        config._title = title !== null && title !== void 0 ? title : this.title;
-        config._ending = ending !== null && ending !== void 0 ? ending : this.ending;
-        config._bypass = bypass !== null && bypass !== void 0 ? bypass : this.bypass;
-        config._surname = surname !== null && surname !== void 0 ? surname : this.surname;
+        const config = _a.create(__classPrivateFieldGet(this, _Config_instances, "m", _Config_genNewName).call(this, name !== null && name !== void 0 ? name : this.name + copyAlias));
+        __classPrivateFieldSet(config, _Config_orderedBy, orderedBy !== null && orderedBy !== void 0 ? orderedBy : this.orderedBy, "f");
+        __classPrivateFieldSet(config, _Config_separator, separator !== null && separator !== void 0 ? separator : this.separator, "f");
+        __classPrivateFieldSet(config, _Config_title, title !== null && title !== void 0 ? title : this.title, "f");
+        __classPrivateFieldSet(config, _Config_ending, ending !== null && ending !== void 0 ? ending : this.ending, "f");
+        __classPrivateFieldSet(config, _Config_bypass, bypass !== null && bypass !== void 0 ? bypass : this.bypass, "f");
+        __classPrivateFieldSet(config, _Config_surname, surname !== null && surname !== void 0 ? surname : this.surname, "f");
         return config;
     }
-    /**
-     * Makes an exact copy of the current configuration.
-     */
     clone() {
         return this.copyWith();
     }
-    /**
-     * Resets the configuration by setting it back to its default values.
-     */
     reset() {
-        this._orderedBy = types_1.NameOrder.FIRST_NAME;
-        this._separator = types_1.Separator.SPACE;
-        this._title = types_1.Title.UK;
-        this._ending = false;
-        this._bypass = true;
-        this._surname = types_1.Surname.FATHER;
-        Config.cache.set(this.name, this);
+        __classPrivateFieldSet(this, _Config_orderedBy, types_1.NameOrder.FIRST_NAME, "f");
+        __classPrivateFieldSet(this, _Config_separator, types_1.Separator.SPACE, "f");
+        __classPrivateFieldSet(this, _Config_title, types_1.Title.UK, "f");
+        __classPrivateFieldSet(this, _Config_ending, false, "f");
+        __classPrivateFieldSet(this, _Config_bypass, true, "f");
+        __classPrivateFieldSet(this, _Config_surname, types_1.Surname.FATHER, "f");
+        _a.cache.set(this.name, this);
     }
-    /**
-     * Alters the name order between the first and last name, and rearrange the
-     * order of appearance of a name set.
-     */
     updateOrder(order) {
-        if (order && order !== this._orderedBy) {
-            Config.cache.get(this.name)._orderedBy = order;
+        if (order && order !== __classPrivateFieldGet(this, _Config_orderedBy, "f")) {
+            __classPrivateFieldSet(_a.cache.get(this.name), _Config_orderedBy, order, "f");
         }
     }
-    /**
-     * Generates a unique new name.
-     */
-    genNewName(name) {
-        return name === this.name || Config.cache.has(name) ? this.genNewName(name + copyAlias) : name;
-    }
 }
 exports.Config = Config;
-/**
- * Cache for multiple instances.
- */
+_a = Config, _Config_name = new WeakMap(), _Config_orderedBy = new WeakMap(), _Config_separator = new WeakMap(), _Config_title = new WeakMap(), _Config_ending = new WeakMap(), _Config_bypass = new WeakMap(), _Config_surname = new WeakMap(), _Config_instances = new WeakSet(), _Config_genNewName = function _Config_genNewName(name) {
+    return name === this.name || _a.cache.has(name) ? __classPrivateFieldGet(this, _Config_instances, "m", _Config_genNewName).call(this, name + copyAlias) : name;
+};
 Config.cache = new Map();
-//# sourceMappingURL=config.js.map

package/dist/lib/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_TOKENS = exports.MAX_NUMBER_OF_NAME_PARTS = exports.MIN_NUMBER_OF_NAME_PARTS = exports.version = void 0;
-exports.version = '1.2.0';
+exports.ALLOWED_TOKENS = exports.MAX_NUMBER_OF_NAME_PARTS = exports.MIN_NUMBER_OF_NAME_PARTS = exports.VERSION = void 0;
+exports.VERSION = '1.3.0';
 exports.MIN_NUMBER_OF_NAME_PARTS = 2;
 exports.MAX_NUMBER_OF_NAME_PARTS = 5;
 exports.ALLOWED_TOKENS = [
@@ -28,4 +28,3 @@ exports.ALLOWED_TOKENS = [
     'S',
     '$',
 ];
-//# sourceMappingURL=constants.js.map

package/dist/lib/error.js

@@ -2,96 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownError = exports.NotAllowedError = exports.ValidationError = exports.InputError = exports.NameError = exports.NameErrorType = void 0;
 const utils_1 = require("./utils");
-/**
- * The error types supported by `Namefully`.
- */
 var NameErrorType;
 (function (NameErrorType) {
-    /**
-     * Thrown when a name entry/argument is incorrect.
-     *
-     * For example, a name should have a minimum of 2 characters, so an empty
-     * string or a string of one character would cause this kind of error.
-     */
     NameErrorType[NameErrorType["INPUT"] = 0] = "INPUT";
-    /**
-     * Thrown when the name components do not match the validation rules if the
-     * `Config.bypass` is not flagged up. This bypass option skips the validation
-     * rules.
-     *
-     * See also: `ValidationError`
-     */
     NameErrorType[NameErrorType["VALIDATION"] = 1] = "VALIDATION";
-    /**
-     * Thrown by not allowed operations such as in NameBuilder or name formatting.
-     *
-     * See also: `NotAllowedError`, `Namefully.format`.
-     */
     NameErrorType[NameErrorType["NOT_ALLOWED"] = 2] = "NOT_ALLOWED";
-    /**
-     * Thrown by any other unknown sources or unexpected situation.
-     */
     NameErrorType[NameErrorType["UNKNOWN"] = 3] = "UNKNOWN";
-})(NameErrorType = exports.NameErrorType || (exports.NameErrorType = {}));
-/**
- * Base class for all name-related errors.
- *
- * A custom error is intended to convey information to the user about a failure,
- * so that it can be addressed programmatically.
- *
- * A name handling failure is not considered a native error that should cause a
- * program failure. Au contraire, it is expected that a programmer using this utility
- * would consider validating a name using its own business rules. That is not
- * this utility's job to guess those rules. So, the predefined `ValidationRules`
- * obey some common validation techniques when it comes to sanitizing a person
- * name. For this reason, the [Config.bypass] is set to `true` by default,
- * indicating that those predefined rules should be skipped for the sake of the
- * program.
- *
- * A programmer may leverage `Parser` to indicate business-tailored rules if he
- * or she wants this utility to perform those safety checks behind the scenes.
- *
- * A name error intends to provide useful information about what causes the error
- * and let the user take initiative on what happens next to the given name:
- * reconstructing it or skipping it.
- */
+})(NameErrorType || (exports.NameErrorType = NameErrorType = {}));
 class NameError extends Error {
-    /**
-     * Creates an error with a message describing the issue for a name source.
-     * @param source name input that caused the error
-     * @param message a message describing the failure.
-     * @param type of `NameErrorType`
-     */
     constructor(source, message, type = NameErrorType.UNKNOWN) {
         super(message);
         this.source = source;
         this.type = type;
         this.name = 'NameError';
     }
-    /**
-     * The actual source input which caused the error.
-     */
     get sourceAsString() {
         let input = '';
         if (!this.source)
             input = '<undefined>';
         if (typeof this.source === 'string')
             input = this.source;
-        if (utils_1.isNameArray(this.source))
+        if ((0, utils_1.isNameArray)(this.source))
             input = this.source.map((n) => n.toString()).join(' ');
-        if (utils_1.isStringArray(this.source))
+        if ((0, utils_1.isStringArray)(this.source))
             input = this.source.join(' ');
         return input;
     }
-    /**
-     * Whether a message describing the failure exists.
-     */
     get hasMessage() {
         return this.message && this.message.trim().length > 0;
     }
-    /**
-     * Returns a string representation of the error.
-     */
     toString() {
         let report = `${this.name} (${this.sourceAsString})`;
         if (this.hasMessage)
@@ -100,42 +39,14 @@ class NameError extends Error {
     }
 }
 exports.NameError = NameError;
-/**
- * An error thrown when a name source input is incorrect.
- *
- * A `Name` is a name for this utility under certain criteria (i.e., 2+ chars),
- * hence, a wrong input will cause this kind of error. Another common reason
- * may be a wrong key in a Json name parsing mechanism.
- *
- * Keep in mind that this error is different from a `ValidationError`.
- */
 class InputError extends NameError {
-    /**
-     * Creates a new `InputError` with an optional error `message`.
-     *
-     * The name source is by nature a string content, maybe wrapped up in a different
-     * type. This string value may be extracted to form the following output:
-     *   "InputError (stringName)",
-     *   "InputError (stringName): message".
-     */
     constructor(error) {
         super(error.source, error.message, NameErrorType.INPUT);
         this.name = 'InputError';
     }
 }
 exports.InputError = InputError;
-/**
- * An error thrown to indicate that a name fails the validation rules.
- */
 class ValidationError extends NameError {
-    /**
-     * Creates error containing the invalid `nameType` and a `message` that
-     * briefly describes the problem if provided.
-     *
-     * For example, a validation error can be interpreted as:
-     *     "ValidationError (nameType='stringName')",
-     *     "ValidationError (nameType='stringName'): message"
-     */
     constructor(error) {
         super(error.source, error.message, NameErrorType.VALIDATION);
         this.nameType = error.nameType;
@@ -149,22 +60,7 @@ class ValidationError extends NameError {
     }
 }
 exports.ValidationError = ValidationError;
-/**
- * Thrown by not allowed operations such as in name formatting.
- *
- * For example, this will occur when trying to format a name accordingly using
- * a non-supported key.
- */
 class NotAllowedError extends NameError {
-    /**
-     * Creates a new `NotAllowedError` with an optional error `message` and the
-     * `operation` name.
-     *
-     * For example, an error of this kind can be interpreted as:
-     *     "NotAllowedError (stringName)",
-     *     "NotAllowedError (stringName) - operationName",
-     *     "NotAllowedError (stringName) - operationName: message"
-     */
     constructor(error) {
         super(error.source, error.message, NameErrorType.NOT_ALLOWED);
         this.operation = error.operation;
@@ -180,20 +76,7 @@ class NotAllowedError extends NameError {
     }
 }
 exports.NotAllowedError = NotAllowedError;
-/**
- * A fallback error thrown by any unknown sources or unexpected failure that are
- * not of `NameError`.
- *
- * In this particular case, an `origin` remains useful as it provides details
- * on the sources and the true nature of the unexpected error.
- * At this point, deciding whether to exit the program or not depends on the
- * programmer.
- */
 class UnknownError extends NameError {
-    /**
-     * Creates a new `UnknownError` with an optional error `message`.
-     * Optionally, the original error revealing the true nature of the failure.
-     */
     constructor(error) {
         super(error.source, error.message, NameErrorType.UNKNOWN);
         this.origin = error.error;
@@ -207,4 +90,3 @@ class UnknownError extends NameError {
     }
 }
 exports.UnknownError = UnknownError;
-//# sourceMappingURL=error.js.map