@fgv/ts-bcp47 0.5.0

package/bcp47/validation/validateTag.js

@@ -0,0 +1,159 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateTag = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const common_1 = require("./common");
+const isCanonical_1 = require("./isCanonical");
+const isInPreferredForm_1 = require("./isInPreferredForm");
+const isStrictlyValid_1 = require("./isStrictlyValid");
+const isValid_1 = require("./isValid");
+const isWellFormed_1 = require("./isWellFormed");
+/**
+ * Validation helpers for BCP-47 language tags.
+ * @public
+ */
+class ValidateTag {
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,
+     * meaning that they are at least well-formed as specified by
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and
+     * all subtags are also
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a language tag in canonical, false otherwise.
+     * @example `en-US` is in canonical form, `en-us` is not.
+     * @example `eng-US` is in canonical form, `eng-us` is not.
+     */
+    static isCanonical(subtags) {
+        if (!this._isCanonical) {
+            this._isCanonical = new isCanonical_1.IsCanonicalValidator();
+        }
+        return this._isCanonical.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * in preferred form. Preferred form is valid as specified by
+     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and
+     * also meets additional preferences specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -
+     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or
+     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag in preferred form, false otherwise.
+     * @example `en-US` is in preferred form, `en-Latn-US` is not.
+     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.
+     */
+    static isInPreferredForm(subtags) {
+        if (!this._isInPreferredForm) {
+            this._isInPreferredForm = new isInPreferredForm_1.IsInPreferredFromValidator();
+        }
+        return this._isInPreferredForm.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * strictly valid.  A strictly valid tag is both
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}
+     * and meets any other requirements such as
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a strictly valid language tag, false otherwise.
+     * @example `ca-valencia` is strictly valid, `es-valencia` is not.
+     */
+    static isStrictlyValid(subtags) {
+        return this.validateSubtags(subtags, 'strictly-valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag, false otherwise.
+     * @example `en-US` is valid, `eng-US` is not.
+     */
+    static isValid(subtags) {
+        return this.validateSubtags(subtags, 'valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags meet the grammar defined in the specification.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a well-formed language tag, false otherwise.
+     * @example `en-US` is valid, `english-US` is not.
+     * @public
+     */
+    static isWellFormed(subtags) {
+        return this.validateSubtags(subtags, 'well-formed').isSuccess();
+    }
+    /**
+     * Chooses an appropriate default tag validator given desired and optional current
+     * {@link Bcp47.TagValidity | validation level}.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no
+     * additional validation is necessary.
+     * @internal
+     */
+    static chooseValidator(wantValidity, haveValidity) {
+        if (haveValidity && (0, common_1.compareValidity)(haveValidity, wantValidity) >= 0) {
+            return undefined;
+        }
+        if (!this._validators) {
+            this._validators = {
+                /* eslint-disable @typescript-eslint/naming-convention */
+                unknown: new isWellFormed_1.IsWellFormedValidator(),
+                'well-formed': new isWellFormed_1.IsWellFormedValidator(),
+                valid: new isValid_1.IsValidValidator(),
+                'strictly-valid': new isStrictlyValid_1.IsStrictlyValidValidator(),
+                /* eslint-enable @typescript-eslint/naming-convention */
+            };
+        }
+        return this._validators[wantValidity];
+    }
+    /**
+     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested
+     * {@link Bcp47.TagValidity | validity level}, if necessary.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or
+     * `Failure` with details if an error occurs.
+     * @public
+     */
+    static validateSubtags(subtags, wantValidity, haveValidity) {
+        var _a;
+        const validator = this.chooseValidator(wantValidity, haveValidity);
+        // istanbul ignore next - a pain to test
+        return (_a = validator === null || validator === void 0 ? void 0 : validator.validateSubtags(subtags)) !== null && _a !== void 0 ? _a : (0, ts_utils_1.succeed)(true);
+    }
+}
+exports.ValidateTag = ValidateTag;
+ValidateTag._validators = undefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validateTag.js","sourceRoot":"","sources":["../../../src/bcp47/validation/validateTag.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAgD;AAChD,qCAAwD;AAExD,+CAAqD;AACrD,2DAAiE;AACjE,uDAA6D;AAC7D,uCAA6C;AAC7C,iDAAuD;AAIvD;;;GAGG;AACH,MAAa,WAAW;IAKpB;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,WAAW,CAAC,OAAgB;QACtC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,IAAI,CAAC,YAAY,GAAG,IAAI,kCAAoB,EAAE,CAAC;SAClD;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,iBAAiB,CAAC,OAAgB;QAC5C,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC1B,IAAI,CAAC,kBAAkB,GAAG,IAAI,8CAA0B,EAAE,CAAC;SAC9D;QACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IACxE,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,eAAe,CAAC,OAAgB;QAC1C,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,SAAS,EAAE,CAAC;IACvE,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,OAAO,CAAC,OAAgB;QAClC,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IAC9D,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,YAAY,CAAC,OAAgB;QACvC,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,SAAS,EAAE,CAAC;IACpE,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,eAAe,CAAC,YAAyB,EAAE,YAA0B;QAC/E,IAAI,YAAY,IAAI,IAAA,wBAAe,EAAC,YAAY,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE;YAClE,OAAO,SAAS,CAAC;SACpB;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,IAAI,CAAC,WAAW,GAAG;gBACf,yDAAyD;gBACzD,OAAO,EAAE,IAAI,oCAAqB,EAAE;gBACpC,aAAa,EAAE,IAAI,oCAAqB,EAAE;gBAC1C,KAAK,EAAE,IAAI,0BAAgB,EAAE;gBAC7B,gBAAgB,EAAE,IAAI,0CAAwB,EAAE;gBAChD,wDAAwD;aAC3D,CAAC;SACL;QACD,OAAO,IAAI,CAAC,WAAY,CAAC,YAAY,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,eAAe,CAAC,OAAgB,EAAE,YAAyB,EAAE,YAA0B;;QACjG,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QACnE,wCAAwC;QACxC,OAAO,MAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,eAAe,CAAC,OAAO,CAAC,mCAAI,IAAA,kBAAO,EAAC,IAAI,CAAC,CAAC;IAChE,CAAC;;AAjIL,kCAkIC;AA/HkB,uBAAW,GAAkD,SAAS,CAAC","sourcesContent":["/*\n * Copyright (c) 2022 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, succeed } from '@fgv/ts-utils';\nimport { TagValidity, compareValidity } from './common';\n\nimport { IsCanonicalValidator } from './isCanonical';\nimport { IsInPreferredFromValidator } from './isInPreferredForm';\nimport { IsStrictlyValidValidator } from './isStrictlyValid';\nimport { IsValidValidator } from './isValid';\nimport { IsWellFormedValidator } from './isWellFormed';\nimport { Subtags } from '../common';\nimport { TagValidator } from './baseValidator';\n\n/**\n * Validation helpers for BCP-47 language tags.\n * @public\n */\nexport class ValidateTag {\n    private static _isCanonical?: TagValidator;\n    private static _isInPreferredForm?: TagValidator;\n    private static _validators: Record<TagValidity, TagValidator> | undefined = undefined;\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,\n     * meaning that they are at least well-formed as specified by\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and\n     * all subtags are also\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a language tag in canonical, false otherwise.\n     * @example `en-US` is in canonical form, `en-us` is not.\n     * @example `eng-US` is in canonical form, `eng-us` is not.\n     */\n    public static isCanonical(subtags: Subtags): boolean {\n        if (!this._isCanonical) {\n            this._isCanonical = new IsCanonicalValidator();\n        }\n        return this._isCanonical.validateSubtags(subtags).isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * in preferred form. Preferred form is valid as specified by\n     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and\n     * also meets additional preferences specified in the\n     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -\n     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or\n     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a valid language tag in preferred form, false otherwise.\n     * @example `en-US` is in preferred form, `en-Latn-US` is not.\n     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.\n     */\n    public static isInPreferredForm(subtags: Subtags): boolean {\n        if (!this._isInPreferredForm) {\n            this._isInPreferredForm = new IsInPreferredFromValidator();\n        }\n        return this._isInPreferredForm.validateSubtags(subtags).isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * strictly valid.  A strictly valid tag is both\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}\n     * and meets any other requirements such as\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a strictly valid language tag, false otherwise.\n     * @example `ca-valencia` is strictly valid, `es-valencia` is not.\n     */\n    public static isStrictlyValid(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'strictly-valid').isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},\n     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the\n     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a valid language tag, false otherwise.\n     * @example `en-US` is valid, `eng-US` is not.\n     */\n    public static isValid(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'valid').isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},\n     * meaning that all subtags meet the grammar defined in the specification.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a well-formed language tag, false otherwise.\n     * @example `en-US` is valid, `english-US` is not.\n     * @public\n     */\n    public static isWellFormed(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'well-formed').isSuccess();\n    }\n\n    /**\n     * Chooses an appropriate default tag validator given desired and optional current\n     * {@link Bcp47.TagValidity | validation level}.\n     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.\n     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.\n     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no\n     * additional validation is necessary.\n     * @internal\n     */\n    public static chooseValidator(wantValidity: TagValidity, haveValidity?: TagValidity): TagValidator | undefined {\n        if (haveValidity && compareValidity(haveValidity, wantValidity) >= 0) {\n            return undefined;\n        }\n\n        if (!this._validators) {\n            this._validators = {\n                /* eslint-disable @typescript-eslint/naming-convention */\n                unknown: new IsWellFormedValidator(),\n                'well-formed': new IsWellFormedValidator(),\n                valid: new IsValidValidator(),\n                'strictly-valid': new IsStrictlyValidValidator(),\n                /* eslint-enable @typescript-eslint/naming-convention */\n            };\n        }\n        return this._validators![wantValidity];\n    }\n\n    /**\n     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested\n     * {@link Bcp47.TagValidity | validity level}, if necessary.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.\n     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.\n     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.\n     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or\n     * `Failure` with details if an error occurs.\n     * @public\n     */\n    public static validateSubtags(subtags: Subtags, wantValidity: TagValidity, haveValidity?: TagValidity): Result<boolean> {\n        const validator = this.chooseValidator(wantValidity, haveValidity);\n        // istanbul ignore next - a pain to test\n        return validator?.validateSubtags(subtags) ?? succeed(true);\n    }\n}\n"]}

package/data/bcp/overrides.json

@@ -0,0 +1,21 @@
+[
+    {
+        "language": "en",
+        "defaultAffinity": "GB",
+        "affinity": {
+            "us": ["GU", "PH", "PR", "UM", "US", "VI"]
+        }
+    },
+    {
+        "language": "es",
+        "defaultAffinity": "419",
+        "affinity": {
+            "es": ["ES", "GQ", "IC"]
+        }
+    },
+    {
+        "language": "fr",
+        "preferredRegion": "FR"
+    }
+]
+