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

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

@@ -0,0 +1,102 @@
+/*
+ * 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, 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 IsWellFormedValidator extends TagValidatorBase {
+  public validity: TagValidity = 'well-formed';
+
+  protected _checkLanguage(subtags: ISubtags): Result<Iana.LanguageSubtags.LanguageSubtag | undefined> {
+    return subtags.primaryLanguage
+      ? this.iana.subtags.languages.verifyIsWellFormed(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.verifyIsWellFormed(e)),
+        subtags.extlangs
+      );
+    }
+    return succeed(undefined);
+  }
+
+  protected _checkScript(subtags: ISubtags): Result<Iana.LanguageSubtags.ScriptSubtag | undefined> {
+    return subtags.script ? this.iana.subtags.scripts.verifyIsWellFormed(subtags.script) : succeed(undefined);
+  }
+
+  protected _checkRegion(subtags: ISubtags): Result<Iana.LanguageSubtags.RegionSubtag | undefined> {
+    return subtags.region ? this.iana.subtags.regions.verifyIsWellFormed(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.verifyIsWellFormed(v)),
+        subtags.variants
+      );
+    }
+    return succeed(undefined);
+  }
+
+  protected _checkExtensionSingleton(singleton: ExtensionSingleton): Result<ExtensionSingleton> {
+    return this.iana.extensions.extensions.verifyIsWellFormed(singleton);
+  }
+
+  protected _checkExtensionSubtagValue(value: ExtensionSubtag): Result<ExtensionSubtag> {
+    return Bcp47Subtags.Validate.extensionSubtag.verifyIsWellFormed(value);
+  }
+
+  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.verifyIsWellFormed(subtags.grandfathered)
+      : succeed(undefined);
+  }
+}

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

@@ -0,0 +1,175 @@
+/*
+ * 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 { Result, succeed } from '@fgv/ts-utils';
+import { TagValidity, compareValidity } from './common';
+
+import { ISubtags } from '../common';
+import { ITagValidator } from './baseValidator';
+import { IsCanonicalValidator } from './isCanonical';
+import { IsInPreferredFromValidator } from './isInPreferredForm';
+import { IsStrictlyValidValidator } from './isStrictlyValid';
+import { IsValidValidator } from './isValid';
+import { IsWellFormedValidator } from './isWellFormed';
+
+/**
+ * Validation helpers for BCP-47 language tags.
+ * @public
+ */
+export class ValidateTag {
+  private static _isCanonical?: ITagValidator;
+  private static _isInPreferredForm?: ITagValidator;
+  private static _validators: Record<TagValidity, ITagValidator> | undefined = undefined;
+
+  /**
+   * 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.
+   */
+  public static isCanonical(subtags: ISubtags): boolean {
+    if (!this._isCanonical) {
+      this._isCanonical = new 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.
+   */
+  public static isInPreferredForm(subtags: ISubtags): boolean {
+    if (!this._isInPreferredForm) {
+      this._isInPreferredForm = new 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.
+   */
+  public static isStrictlyValid(subtags: ISubtags): boolean {
+    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.
+   */
+  public static isValid(subtags: ISubtags): boolean {
+    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
+   */
+  public static isWellFormed(subtags: ISubtags): boolean {
+    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
+   */
+  public static chooseValidator(
+    wantValidity: TagValidity,
+    haveValidity?: TagValidity
+  ): ITagValidator | undefined {
+    if (haveValidity && compareValidity(haveValidity, wantValidity) >= 0) {
+      return undefined;
+    }
+
+    if (!this._validators) {
+      this._validators = {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        unknown: new IsWellFormedValidator(),
+        'well-formed': new IsWellFormedValidator(),
+        valid: new IsValidValidator(),
+        'strictly-valid': new 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
+   */
+  public static validateSubtags(
+    subtags: ISubtags,
+    wantValidity: TagValidity,
+    haveValidity?: TagValidity
+  ): Result<boolean> {
+    const validator = this.chooseValidator(wantValidity, haveValidity);
+    // istanbul ignore next - a pain to test
+    return validator?.validateSubtags(subtags) ?? succeed(true);
+  }
+}

package/src/packlets/iana/common/converters.ts

@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+/* eslint-disable @rushstack/typedef-var */
+
+import * as Validate from './validate';
+
+import { Converter, Converters } from '@fgv/ts-utils';
+import { IDatedRegistry } from './model';
+
+/**
+ * Validating converter from string {@link Iana.Model.YearMonthDaySpec}.
+ * @public
+ */
+export const yearMonthDaySpec = Validate.yearMonthDateSpec.converter;
+
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha2RegionCode}.
+ * @public
+ */
+export const isoAlpha2RegionCode = Validate.isoAlpha2RegionCode.converter;
+
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha3RegionCode}.
+ * @public
+ */
+export const isoAlpha3RegionCode = Validate.isoAlpha3RegionCode.converter;
+
+/**
+ * Validating converter from string {@link Iana.Model.UnM49RegionCode}.
+ * @public
+ */
+export const unM49RegionCode = Validate.unM49RegionCode.converter;
+
+/**
+ * Helper function which creates a converter that returns a validated {@Link Iana.Model.IDatedRegistry | DatedRegistry}
+ * containing entries of supplied template type `T`.
+ * @param entryConverter - A `Converter<T>` to validate each entry
+ * @returns A new validating `Converter` which yields {@Link Iana.Model.IDatedRegistry | DatedRegistry<T>}
+ * @public
+ */
+export function datedRegistry<T, TC = unknown>(
+  entryConverter: Converter<T, TC>
+): Converter<IDatedRegistry<T>, unknown> {
+  return Converters.strictObject<IDatedRegistry<T>, unknown>({
+    fileDate: yearMonthDaySpec,
+    entries: Converters.arrayOf(entryConverter)
+  });
+}

package/src/packlets/iana/common/model.ts

@@ -0,0 +1,56 @@
+/*
+ * 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 { Brand } from '@fgv/ts-utils';
+
+/**
+ * Represents an ISO 3166 Alpha-2 region code.
+ * @public
+ */
+export type IsoAlpha2RegionCode = Brand<string, 'IsoAlpha2RegionCode'>;
+
+/**
+ * Represents an ISO 3166 Alpha-3 region code.
+ * @public
+ */
+export type IsoAlpha3RegionCode = Brand<string, 'IsoAlpha3RegionCode'>;
+
+/**
+ * Represents a UN M.49 numeric region code.
+ * @public
+ */
+export type UnM49RegionCode = Brand<string, 'UnM49RegionCode'>;
+
+/**
+ * Represents a date string in the format YYYY-MM-DD.
+ * @public
+ */
+export type YearMonthDaySpec = Brand<string, 'YearMonthDaySpec'>;
+
+/**
+ * A dated collection of registry entries of a specified templated type.
+ * @public
+ */
+export interface IDatedRegistry<T> {
+  fileDate: YearMonthDaySpec;
+  entries: T[];
+}

package/src/packlets/iana/common/registeredItems.ts

@@ -0,0 +1,145 @@
+/*
+ * 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 { Result, fail, succeed } from '@fgv/ts-utils';
+import { ValidationHelpers } from '../../utils';
+
+/**
+ * @internal
+ */
+export abstract class RegisteredItemScope<TTYPE extends string, TKEY extends string, TITEM> {
+  protected readonly _items: Map<TKEY, TITEM>;
+  protected readonly _type: TTYPE;
+  protected readonly _validate: ValidationHelpers<TKEY>;
+
+  protected constructor(type: TTYPE, validate: ValidationHelpers<TKEY>) {
+    this._items = new Map();
+    this._type = type;
+    this._validate = validate;
+  }
+
+  public getAllKeys(): TKEY[] {
+    return Array.from(this._items.keys());
+  }
+
+  public getAll(): TITEM[] {
+    return Array.from(this._items.values());
+  }
+
+  public tryGet(want: string | undefined): TITEM | undefined {
+    if (want) {
+      const got = this._items.get(want as TKEY);
+      if (!got) {
+        const result = this.toCanonical(want);
+        if (result.isSuccess()) {
+          return this._items.get(result.value as TKEY);
+        }
+      }
+      return got;
+    }
+    return undefined;
+  }
+
+  public tryGetCanonical(want: string | undefined): TITEM | undefined {
+    return want ? this._items.get(want as TKEY) : undefined;
+  }
+
+  public get(want: string | undefined): Result<TITEM> {
+    const got = this.tryGet(want);
+    return got ? succeed(got) : fail(`invalid ${this._type}`);
+  }
+
+  public getCanonical(want: string | undefined): Result<TITEM | undefined> {
+    const got = this.tryGetCanonical(want);
+    return got ? succeed(got) : fail(`invalid ${this._type}`);
+  }
+
+  public isWellFormed(val: unknown): val is TKEY {
+    return this._validate.isWellFormed(val);
+  }
+
+  public isCanonical(val: unknown): val is TKEY {
+    return this._validate.isCanonical(val);
+  }
+
+  public toCanonical(val: unknown): Result<TKEY> {
+    return this._validate.toCanonical(val);
+  }
+
+  public toValidCanonical(val: unknown): Result<TKEY> {
+    return this._validate.toCanonical(val).onSuccess((canonical) => {
+      if (this._items.has(canonical)) {
+        return succeed(canonical);
+      }
+      return fail(`${val}: invalid ${this._type}`);
+    });
+  }
+
+  public isValid(val: unknown): val is TKEY {
+    const result = this.toCanonical(val);
+    if (result.isSuccess()) {
+      return this._items.has(result.value);
+    }
+    return false;
+  }
+
+  public isValidCanonical(val: unknown): val is TKEY {
+    if (this.isCanonical(val)) {
+      return this._items.has(val);
+    }
+    return false;
+  }
+
+  public verifyIsWellFormed(val: unknown): Result<TKEY> {
+    return this._validate.verifyIsWellFormed(val);
+  }
+
+  public verifyIsValid(val: unknown): Result<TKEY> {
+    if (this.isValid(val)) {
+      return succeed(val);
+    }
+    if (!this.isWellFormed(val)) {
+      return fail(`${val}: malformed ${this._type}.`);
+    }
+    return fail(`${val}: invalid ${this._type}.`);
+  }
+
+  public verifyIsCanonical(val: unknown): Result<TKEY> {
+    if (this.isCanonical(val)) {
+      return succeed(val);
+    }
+    if (!this.isWellFormed(val)) {
+      return fail(`${val}: malformed ${this._type}`);
+    }
+    return fail(`${val}: non-canonical ${this._type}`);
+  }
+
+  protected _validateKey(key: TKEY): Result<true> {
+    if (!this.isCanonical(key)) {
+      return fail(`${key}: ${this._type} is not in canonical form`);
+    }
+    return succeed(true);
+  }
+
+  public abstract add(entry: TITEM): Result<true>;
+  protected abstract _validateEntry(entry: TITEM): Result<true>;
+}

package/src/packlets/iana/common/utils.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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 { DateTime } from 'luxon';
+import { YearMonthDaySpec } from './model';
+
+/**
+ * Gets the current date as an {@link Iana.Model.YearMonthDaySpec | YearMonthDaySpec }.
+ * @public
+ */
+export function nowAsYearMonthDay(): YearMonthDaySpec {
+  return DateTime.now().toFormat('yyyy-LL-dd') as YearMonthDaySpec;
+}

package/src/packlets/iana/common/validate.ts

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+/* eslint-disable @rushstack/typedef-var */
+
+import { succeed } from '@fgv/ts-utils';
+import { RegExpValidationHelpers } from '../../utils';
+import * as Model from './model';
+
+/**
+ * @public
+ */
+export const yearMonthDateSpec = new RegExpValidationHelpers<Model.YearMonthDaySpec>({
+  description: 'Year-Month-Date value',
+  wellFormed: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/,
+  canonical: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
+});
+
+/**
+ * @public
+ */
+export const isoAlpha2RegionCode = new RegExpValidationHelpers<Model.IsoAlpha2RegionCode>({
+  description: 'ISO 3166-2 Alpha-2 region code',
+  wellFormed: /^[A-Za-z]{2}$/,
+  canonical: /^[A-Z]{2}$/,
+  toCanonical: (from: Model.IsoAlpha2RegionCode) => succeed(from.toUpperCase() as Model.IsoAlpha2RegionCode)
+});
+
+/**
+ * @public
+ */
+export const isoAlpha3RegionCode = new RegExpValidationHelpers<Model.IsoAlpha3RegionCode>({
+  description: 'ISO 3166-2 Alpha-3 region code',
+  wellFormed: /^[A-Za-z]{3}$/,
+  canonical: /^[A-Z]{3}$/,
+  toCanonical: (from: Model.IsoAlpha3RegionCode) => succeed(from.toUpperCase() as Model.IsoAlpha3RegionCode)
+});
+
+/**
+ * @public
+ */
+export const unM49RegionCode = new RegExpValidationHelpers<Model.UnM49RegionCode>({
+  description: 'UN M.49 3-digit region code',
+  wellFormed: /^[0-9]{3}$/,
+  canonical: /^[0-9]{3}$/
+});

package/src/packlets/iana/converters.ts

@@ -0,0 +1,26 @@
+/*
+ * 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 Jar from './jar/jarConverters';
+
+export * from './common/converters';
+export { Jar };