@fgv/ts-bcp47 5.0.0-21 → 5.0.0-23

package/src/packlets/bcp47/validation/baseValidator.ts

@@ -1,132 +0,0 @@
-/*
- * 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.
- */
-
-import * as Iana from '../../iana';
-
-import { Result, allSucceed, fail, succeed } from '@fgv/ts-utils';
-import { ExtensionSingleton, ExtensionSubtag } from '../bcp47Subtags/model';
-import { IExtensionSubtagValue, ISubtags, subtagsToString } from '../common';
-import { TagValidity } from './common';
-
-/**
- * @public
- */
-export interface ITagValidator {
-  readonly validity: TagValidity;
-
-  validateSubtags(subtags: ISubtags): Result<true>;
-}
-
-/**
- * @internal
- */
-export abstract class TagValidatorBase implements ITagValidator {
-  public readonly iana: Iana.LanguageRegistries;
-  public abstract readonly validity: TagValidity;
-
-  public constructor(iana?: Iana.LanguageRegistries) {
-    /* c8 ignore next */
-    this.iana = iana ?? Iana.DefaultRegistries.languageRegistries;
-  }
-
-  public validateSubtags(subtags: ISubtags): Result<true> {
-    return allSucceed(
-      [
-        this._checkLanguage(subtags),
-        this._checkExtlangs(subtags),
-        this._checkScript(subtags),
-        this._checkRegion(subtags),
-        this._checkVariants(subtags),
-        this._checkExtensions(subtags),
-        this._checkPrivateUseTags(subtags),
-        this._checkGrandfatheredTags(subtags)
-      ],
-      true
-    ).onSuccess(() => {
-      return this._postValidate(subtags).onSuccess(() => succeed(true));
-    });
-  }
-
-  protected _basicPostValidation(subtags: ISubtags): Result<ISubtags> {
-    if (
-      subtags.primaryLanguage === undefined &&
-      subtags.grandfathered === undefined &&
-      subtags.privateUse === undefined
-    ) {
-      return fail(`${subtagsToString(subtags)}: missing primary language subtag.`);
-    }
-    if (subtags.extlangs && subtags.extlangs.length > 3) {
-      return fail(`${subtagsToString(subtags)}: too many extlang subtags`);
-    }
-    return succeed(subtags);
-  }
-
-  protected _postValidate(subtags: ISubtags): Result<ISubtags> {
-    return this._basicPostValidation(subtags);
-  }
-
-  protected _checkExtensions(subtags: ISubtags): Result<IExtensionSubtagValue[] | undefined> {
-    if (subtags.extensions) {
-      return allSucceed(
-        subtags.extensions.map((ext) => {
-          return this._checkExtensionSingleton(ext.singleton).onSuccess(() => {
-            return this._checkExtensionSubtagValue(ext.value);
-          });
-        }),
-        subtags.extensions
-      );
-    }
-    return succeed(undefined);
-  }
-
-  protected _verifyUnique<T, TK extends string>(
-    description: string,
-    items: T[] | undefined,
-    getKey: (item: T) => TK
-  ): Result<T[] | undefined> {
-    if (items) {
-      const present = new Set<TK>();
-      return allSucceed(
-        items.map((i) => {
-          const key = getKey(i);
-          if (present.has(key)) {
-            return fail(`${key}: duplicate ${description}`);
-          }
-          present.add(key);
-          return succeed(key);
-        }),
-        items
-      );
-    }
-    return succeed(items);
-  }
-
-  protected abstract _checkLanguage(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkExtlangs(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkScript(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkRegion(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkVariants(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkExtensionSingleton(singleton: ExtensionSingleton): Result<unknown>;
-  protected abstract _checkExtensionSubtagValue(value: ExtensionSubtag): Result<unknown>;
-  protected abstract _checkPrivateUseTags(subtags: ISubtags): Result<unknown>;
-  protected abstract _checkGrandfatheredTags(subtags: ISubtags): Result<unknown>;
-}

package/src/packlets/bcp47/validation/common.ts

@@ -1,86 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Describes the validation level of a particular tag.
- * @public
- */
-export type TagValidity = 'unknown' | 'well-formed' | 'valid' | 'strictly-valid';
-
-/**
- * Ordered ranking of the degrees of validity, from `unknown` (least
- * validation) to `strictly-valid` (fully validated).
- * @public
- */
-const validityRank: Record<TagValidity, number> = {
-  /* eslint-disable @typescript-eslint/naming-convention */
-  /**
-   * No validation has been performed.
-   */
-  unknown: 0,
-  /**
-   * Tag is well-formed {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646}.
-   */
-  'well-formed': 0.5,
-  /**
-   * Tag is valid {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646} -
-   * well-formed, and is a registered grandfathered tag or all subtags are registered,
-   * with no duplicate extensions or variant subtags.
-   */
-  valid: 0.9,
-  /**
-   * Tag is valid {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646} and meets
-   * other constraints described by the RFC - e.g. if present, any extlang or variant subtags have a
-   * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | valid prefix} as specified by
-   * the registry.
-   */
-  'strictly-valid': 1.0
-  /* eslint-enable @typescript-eslint/naming-convention */
-};
-
-/**
- * Determines which of two validity ranks is most normalized.
- * @param v1 - The first {@link TagValidity} to be compared.
- * @param v2 - The second {@link TagValidity} to be compared.
- * @returns `1` if `v1` is more normalized, `-1` if `v2` is more
- * normalized, or `0` if they are identical.
- * @public
- */
-export function compareValidity(v1: TagValidity, v2: TagValidity): -1 | 0 | 1 {
-  if (validityRank[v1] > validityRank[v2]) {
-    return 1;
-  } else if (validityRank[v1] < validityRank[v2]) {
-    return -1;
-  }
-  return 0;
-}
-
-/**
- * Chooses the most valid of two normalization ranks.
- * @param v1 - The first {@link TagValidity} to be compared.
- * @param v2 - The second {@link TagValidity} to be compared.
- * @returns The most validated of `v1` or `v2`.
- * @public
- */
-export function mostValid(v1: TagValidity, v2: TagValidity): TagValidity {
-  return validityRank[v1] >= validityRank[v2] ? v1 : v2;
-}

package/src/packlets/bcp47/validation/index.ts

@@ -1,29 +0,0 @@
-/*
- * 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.
- */
-// istanbul ignore file
-
-export * from './common';
-export { IsCanonicalValidator } from './isCanonical';
-export { IsStrictlyValidValidator } from './isStrictlyValid';
-export { IsValidValidator } from './isValid';
-export { IsWellFormedValidator } from './isWellFormed';
-export { ValidateTag } from './validateTag';

package/src/packlets/bcp47/validation/isCanonical.ts

@@ -1,103 +0,0 @@
-/*
- * 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.
- */
-
-import * as Iana from '../../iana';
-import * as Bcp47Subtags from '../bcp47Subtags';
-
-import { Result, allSucceed, fail, succeed } from '@fgv/ts-utils';
-import { ExtensionSingleton, ExtensionSubtag } from '../bcp47Subtags/model';
-
-import { ISubtags } from '../common';
-import { TagValidatorBase } from './baseValidator';
-import { TagValidity } from './common';
-
-/**
- * @internal
- */
-export class IsCanonicalValidator extends TagValidatorBase {
-  public validity: TagValidity = 'well-formed';
-
-  protected _checkLanguage(subtags: ISubtags): Result<Iana.LanguageSubtags.LanguageSubtag | undefined> {
-    if (subtags.primaryLanguage) {
-      return this.iana.subtags.languages.verifyIsCanonical(subtags.primaryLanguage);
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkExtlangs(subtags: ISubtags): Result<Iana.LanguageSubtags.ExtLangSubtag[] | undefined> {
-    if (subtags.extlangs) {
-      return allSucceed(
-        subtags.extlangs.map((e) => this.iana.subtags.extlangs.verifyIsCanonical(e)),
-        subtags.extlangs
-      );
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkScript(subtags: ISubtags): Result<Iana.LanguageSubtags.ScriptSubtag | undefined> {
-    return subtags.script ? this.iana.subtags.scripts.verifyIsCanonical(subtags.script) : succeed(undefined);
-  }
-
-  protected _checkRegion(subtags: ISubtags): Result<Iana.LanguageSubtags.RegionSubtag | undefined> {
-    return subtags.region ? this.iana.subtags.regions.verifyIsCanonical(subtags.region) : succeed(undefined);
-  }
-
-  protected _checkVariants(subtags: ISubtags): Result<Iana.LanguageSubtags.VariantSubtag[] | undefined> {
-    if (subtags.variants) {
-      return allSucceed(
-        subtags.variants.map((v) => this.iana.subtags.variants.verifyIsCanonical(v)),
-        subtags.variants
-      );
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkExtensionSingleton(singleton: ExtensionSingleton): Result<ExtensionSingleton> {
-    return this.iana.extensions.extensions.verifyIsCanonical(singleton);
-  }
-
-  protected _checkExtensionSubtagValue(value: ExtensionSubtag): Result<ExtensionSubtag> {
-    return Bcp47Subtags.Validate.extensionSubtag.verifyIsCanonical(value);
-  }
-
-  protected _checkPrivateUseTags(
-    subtags: ISubtags
-  ): Result<Iana.LanguageSubtags.ExtendedLanguageRange[] | undefined> {
-    if (subtags.privateUse) {
-      const result = Iana.LanguageSubtags.Validate.extendedLanguageRange.verifyIsCanonical(
-        subtags.privateUse.join('-') as Iana.LanguageSubtags.ExtendedLanguageRange
-      );
-      if (result.isFailure()) {
-        return fail(result.message);
-      }
-    }
-    return succeed(subtags.privateUse);
-  }
-
-  protected _checkGrandfatheredTags(
-    subtags: ISubtags
-  ): Result<Iana.LanguageSubtags.GrandfatheredTag | undefined> {
-    return subtags.grandfathered
-      ? this.iana.subtags.grandfathered.verifyIsCanonical(subtags.grandfathered)
-      : succeed(undefined);
-  }
-}

package/src/packlets/bcp47/validation/isInPreferredForm.ts

@@ -1,53 +0,0 @@
-/*
- * 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.
- */
-
-import * as Iana from '../../iana';
-
-import { Result, fail, succeed } from '@fgv/ts-utils';
-import { ISubtags, subtagsToString } from '../common';
-import { NormalizeTag } from '../normalization';
-import { ITagValidator } from './baseValidator';
-import { TagValidity } from './common';
-
-/**
- * @internal
- */
-export class IsInPreferredFromValidator implements ITagValidator {
-  public readonly iana: Iana.LanguageRegistries;
-  public readonly validity: TagValidity = 'valid';
-
-  public constructor(iana?: Iana.LanguageRegistries) {
-    /* c8 ignore next */
-    this.iana = iana ?? Iana.DefaultRegistries.languageRegistries;
-  }
-
-  public validateSubtags(subtags: ISubtags): Result<true> {
-    return NormalizeTag.toPreferred(subtags).onSuccess((preferred) => {
-      const want = subtagsToString(preferred);
-      const have = subtagsToString(subtags);
-      if (want !== have) {
-        return fail(`${have}: does not match preferred form ${want}`);
-      }
-      return succeed(true);
-    });
-  }
-}

package/src/packlets/bcp47/validation/isStrictlyValid.ts

@@ -1,117 +0,0 @@
-/*
- * 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.
- */
-
-import * as Iana from '../../iana';
-
-import { Result, fail, mapResults, succeed } from '@fgv/ts-utils';
-import { ISubtags, subtagsToString } from '../common';
-import { NormalizeTag, TagNormalization } from '../normalization';
-
-import { TagValidity } from './common';
-import { IsValidValidator } from './isValid';
-
-/**
- * @internal
- */
-export class IsStrictlyValidValidator extends IsValidValidator {
-  public validity: TagValidity = 'strictly-valid';
-  public normalization: TagNormalization = 'unknown';
-
-  protected _checkExtlangs(subtags: ISubtags): Result<Iana.LanguageSubtags.ExtLangSubtag[] | undefined> {
-    if (subtags.extlangs) {
-      return super._checkExtlangs(subtags).onSuccess(() => this._validateExtlangPrefix(subtags));
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkVariants(subtags: ISubtags): Result<Iana.LanguageSubtags.VariantSubtag[] | undefined> {
-    if (subtags.variants) {
-      return super._checkVariants(subtags).onSuccess((v) => this._validateVariantPrefix(subtags, v!));
-    }
-    return succeed(undefined);
-  }
-
-  protected _validateExtlangPrefix(
-    subtags: Readonly<ISubtags>
-  ): Result<Iana.LanguageSubtags.ExtLangSubtag[] | undefined> {
-    if (subtags.extlangs) {
-      const prefix = this.iana.subtags.languages.toCanonical(subtags.primaryLanguage).orDefault();
-      if (!prefix) {
-        return fail('missing primary language for extlang prefix validation.');
-      }
-
-      return mapResults(
-        subtags.extlangs.map((extlang) => {
-          const def = this.iana.subtags.extlangs.tryGet(extlang);
-          /* c8 ignore next 3 - should never happen due to guards earlier in conversion */
-          if (!def) {
-            return fail(`invalid extlang subtag "${extlang}" (not registered).`);
-          }
-          if (prefix !== def.prefix) {
-            return fail(
-              `invalid prefix "${prefix}" for extlang subtag ${extlang} (expected "${def.prefix}").`
-            );
-          }
-          return succeed(extlang);
-        })
-      );
-    }
-    /* c8 ignore next 2 - should be caught in the caller */
-    return succeed(undefined);
-  }
-
-  protected _validateVariantPrefix(
-    subtags: Readonly<ISubtags>,
-    variants: Iana.LanguageSubtags.VariantSubtag[]
-  ): Result<Iana.LanguageSubtags.VariantSubtag[] | undefined> {
-    const { primaryLanguage, extlangs, script, region } = subtags;
-    const nonCanonical = { primaryLanguage, extlangs, script, region };
-    const canonical = NormalizeTag.normalizeSubtags(nonCanonical, 'canonical');
-    /* c8 ignore next 3 - should be caught in the first pass */
-    if (canonical.isFailure()) {
-      return fail(`failed to normalize variant prefix: ${canonical.message}`);
-    }
-    let prefix = subtagsToString(canonical.value);
-
-    return mapResults(
-      variants.map((variant) => {
-        const def = this.iana.subtags.variants.tryGet(variant);
-        /* c8 ignore next 3 - should be caught in the first pass */
-        if (!def) {
-          return fail(`invalid variant subtag "${variant}" (not registered).`);
-        }
-
-        // only fail if registration specifies prefixes but none are present
-        if (def.prefix?.includes(prefix as Iana.LanguageSubtags.ExtendedLanguageRange) === false) {
-          return fail(
-            `invalid prefix "${prefix}" for variant subtag ${variant} (expected "(${def.prefix.join(
-              ', '
-            )})").`
-          );
-        }
-        const canonicalVariant = this.iana.subtags.variants.toCanonical(variant).orDefault();
-        prefix = `${prefix}-${canonicalVariant}`;
-        return succeed(variant);
-      })
-    );
-  }
-}

package/src/packlets/bcp47/validation/isValid.ts

@@ -1,122 +0,0 @@
-/*
- * 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.
- */
-
-import * as Iana from '../../iana';
-import * as Bcp47Subtags from '../bcp47Subtags';
-
-import { Result, allSucceed, fail, mapResults, succeed } from '@fgv/ts-utils';
-import { ExtensionSingleton, ExtensionSubtag } from '../bcp47Subtags/model';
-import { IExtensionSubtagValue, ISubtags } from '../common';
-import { TagValidatorBase } from './baseValidator';
-import { TagValidity } from './common';
-
-/**
- * @internal
- */
-export class IsValidValidator extends TagValidatorBase {
-  public validity: TagValidity = 'valid';
-
-  protected _checkLanguage(subtags: ISubtags): Result<Iana.LanguageSubtags.LanguageSubtag | undefined> {
-    return subtags.primaryLanguage
-      ? this.iana.subtags.languages.verifyIsValid(subtags.primaryLanguage)
-      : succeed(undefined);
-  }
-
-  protected _checkExtlangs(subtags: ISubtags): Result<Iana.LanguageSubtags.ExtLangSubtag[] | undefined> {
-    if (subtags.extlangs) {
-      return allSucceed(
-        subtags.extlangs.map((e) => this.iana.subtags.extlangs.verifyIsValid(e)),
-        subtags.extlangs
-      );
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkScript(subtags: ISubtags): Result<Iana.LanguageSubtags.ScriptSubtag | undefined> {
-    return subtags.script ? this.iana.subtags.scripts.verifyIsValid(subtags.script) : succeed(undefined);
-  }
-
-  protected _checkRegion(subtags: ISubtags): Result<Iana.LanguageSubtags.RegionSubtag | undefined> {
-    return subtags.region ? this.iana.subtags.regions.verifyIsValid(subtags.region) : succeed(undefined);
-  }
-
-  protected _checkVariants(subtags: ISubtags): Result<Iana.LanguageSubtags.VariantSubtag[] | undefined> {
-    if (subtags.variants) {
-      return allSucceed(
-        subtags.variants.map((v) => this.iana.subtags.variants.verifyIsValid(v)),
-        subtags.variants
-      ).onSuccess((v) => {
-        return mapResults(v.map((vc) => this.iana.subtags.variants.toCanonical(vc))).onSuccess(
-          (canonical) => {
-            return this._verifyUnique('variant subtag', canonical, (v) => v);
-          }
-        );
-      });
-    }
-    return succeed(undefined);
-  }
-
-  protected _checkExtensionSingleton(singleton: ExtensionSingleton): Result<ExtensionSingleton> {
-    return this.iana.extensions.extensions.verifyIsValid(singleton);
-  }
-
-  protected _checkExtensionSubtagValue(value: ExtensionSubtag): Result<ExtensionSubtag> {
-    return Bcp47Subtags.Validate.extensionSubtag.verifyIsWellFormed(value);
-  }
-
-  protected _checkExtensions(subtags: ISubtags): Result<IExtensionSubtagValue[] | undefined> {
-    return super._checkExtensions(subtags).onSuccess((extensions) => {
-      return this._verifyUnique('extensions', extensions, (e) => e.singleton.toLowerCase());
-    });
-  }
-
-  protected _checkPrivateUseTags(
-    subtags: ISubtags
-  ): Result<Iana.LanguageSubtags.ExtendedLanguageRange[] | undefined> {
-    if (subtags.privateUse) {
-      return allSucceed(
-        subtags.privateUse.map((pu) =>
-          Iana.LanguageSubtags.Validate.extendedLanguageRange.verifyIsWellFormed(pu)
-        ),
-        subtags.privateUse
-      );
-    }
-    return succeed(subtags.privateUse);
-  }
-
-  protected _checkGrandfatheredTags(
-    subtags: ISubtags
-  ): Result<Iana.LanguageSubtags.GrandfatheredTag | undefined> {
-    return subtags.grandfathered
-      ? this.iana.subtags.grandfathered.verifyIsValid(subtags.grandfathered)
-      : succeed(undefined);
-  }
-
-  protected _postValidate(subtags: ISubtags): Result<ISubtags> {
-    return this._basicPostValidation(subtags).onSuccess((validated) => {
-      if (validated.extlangs && validated.extlangs.length > 1) {
-        return fail(`${validated.extlangs.join('-')}: multiple extlang subtags is invalid`);
-      }
-      return succeed(validated);
-    });
-  }
-}