@siteimprove/alfa-iana 0.89.5

package/dist/language.d.ts

@@ -0,0 +1,187 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { Serializable } from "@siteimprove/alfa-json";
+import { Option } from "@siteimprove/alfa-option";
+import { Result } from "@siteimprove/alfa-result";
+import type * as json from "@siteimprove/alfa-json";
+import { Languages } from "./language/data.js";
+/**
+ * @public
+ */
+export declare class Language implements Equatable, Serializable {
+    static of(primary: Language.Primary, extended?: Option<Language.Extended>, script?: Option<Language.Script>, region?: Option<Language.Region>, variants?: Array<Language.Variant>): Language;
+    private readonly _primary;
+    private readonly _extended;
+    private readonly _script;
+    private readonly _region;
+    private readonly _variants;
+    constructor(primary: Language.Primary, extended: Option<Language.Extended>, script: Option<Language.Script>, region: Option<Language.Region>, variants: Array<Language.Variant>);
+    get primary(): Language.Primary;
+    get extended(): Option<Language.Extended>;
+    get script(): Option<Language.Script>;
+    get region(): Option<Language.Region>;
+    get variants(): Iterable<Language.Variant>;
+    equals(value: unknown): value is this;
+    toJSON(): Language.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Language {
+    interface JSON {
+        [key: string]: json.JSON;
+        type: "language";
+        primary: Primary.JSON;
+        extended: Extended.JSON | null;
+        script: Script.JSON | null;
+        region: Region.JSON | null;
+        variants: Array<Variant.JSON>;
+    }
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-3.1.11}
+     */
+    type Scope = Exclude<Languages["primary"][Primary.Name]["scope"], null>;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-3.1.2}
+     */
+    abstract class Subtag<T extends string = string, N extends string = string> implements Equatable, Serializable<Subtag.JSON<T, N>> {
+        protected readonly _name: N;
+        protected constructor(name: N);
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.3}
+         */
+        abstract get type(): T;
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.4}
+         */
+        get name(): N;
+        abstract equals<T extends string, N extends string>(value: Subtag<T, N>): boolean;
+        abstract equals(value: unknown): value is this;
+        abstract toJSON(): Subtag.JSON<T, N>;
+        toString(): string;
+    }
+    namespace Subtag {
+        interface JSON<T extends string = string, N extends string = string> {
+            [key: string]: json.JSON;
+            type: T;
+            name: N;
+        }
+    }
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.1}
+     */
+    class Primary extends Subtag<"primary", Primary.Name> {
+        static of(name: Primary.Name): Primary;
+        private constructor();
+        get type(): "primary";
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.11}
+         */
+        get scope(): Option<Scope>;
+        equals(value: Primary): boolean;
+        equals(value: unknown): value is this;
+        toJSON(): Primary.JSON;
+    }
+    namespace Primary {
+        type Name = keyof Languages["primary"];
+        interface JSON extends Subtag.JSON<"primary", Name> {
+            scope: Scope | null;
+        }
+        function isPrimary(value: unknown): value is Primary;
+        function isName(name: string): name is Name;
+    }
+    const primary: typeof Primary.of, isPrimary: typeof Primary.isPrimary, isPrimaryName: typeof Primary.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.2}
+     */
+    class Extended extends Subtag<"extended", Extended.Name> {
+        static of(name: Extended.Name): Extended;
+        private constructor();
+        get type(): "extended";
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.8}
+         */
+        get prefix(): Primary.Name;
+        equals(value: Extended): boolean;
+        equals(value: unknown): value is this;
+        toJSON(): Extended.JSON;
+    }
+    namespace Extended {
+        type Name = keyof Languages["extended"];
+        interface JSON extends Subtag.JSON<"extended", Name> {
+            prefix: Primary.Name;
+        }
+        function isExtended(value: unknown): value is Extended;
+        function isName(name: string): name is Name;
+    }
+    const extended: typeof Extended.of, isExtended: typeof Extended.isExtended, isExtendedName: typeof Extended.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.3}
+     */
+    class Script extends Subtag<"script", Script.Name> {
+        static of(name: Script.Name): Script;
+        private constructor();
+        get type(): "script";
+        equals(value: Script): boolean;
+        equals(value: unknown): value is this;
+        toJSON(): Script.JSON;
+    }
+    namespace Script {
+        type Name = keyof Languages["script"];
+        interface JSON extends Subtag.JSON<"script", Name> {
+        }
+        function isScript(value: unknown): value is Script;
+        function isName(name: string): name is Name;
+    }
+    const script: typeof Script.of, isScript: typeof Script.isScript, isScriptName: typeof Script.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.4}
+     */
+    class Region extends Subtag<"region", Region.Name> {
+        static of(name: Region.Name): Region;
+        private constructor();
+        get type(): "region";
+        equals(value: Region): boolean;
+        equals(value: unknown): value is this;
+        toJSON(): Region.JSON;
+    }
+    namespace Region {
+        type Name = keyof Languages["region"];
+        interface JSON extends Subtag.JSON<"region", Name> {
+        }
+        function isRegion(value: unknown): value is Region;
+        function isName(name: string): name is Name;
+    }
+    const region: typeof Region.of, isRegion: typeof Region.isRegion, isRegionName: typeof Region.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.5}
+     */
+    class Variant extends Subtag<"variant", Variant.Name> {
+        static of(name: Variant.Name): Variant;
+        private constructor();
+        get type(): "variant";
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.8}
+         */
+        get prefixes(): ReadonlyArray<string>;
+        equals(value: Variant): boolean;
+        equals(value: unknown): value is this;
+        toJSON(): Variant.JSON;
+    }
+    namespace Variant {
+        type Name = keyof Languages["variant"];
+        interface JSON extends Subtag.JSON<"variant", Name> {
+            prefixes: Array<string>;
+        }
+        function isVariant(value: unknown): value is Variant;
+        function isName(name: string): name is Name;
+    }
+    const variant: typeof Variant.of, isVariant: typeof Variant.isVariant, isVariantName: typeof Variant.isName;
+}
+/**
+ * @public
+ */
+export declare namespace Language {
+    function parse(input: string): Result<Language, string>;
+}
+//# sourceMappingURL=language.d.ts.map

package/dist/language.js

@@ -0,0 +1,331 @@
+import { Option, None } from "@siteimprove/alfa-option";
+import { Result, Err } from "@siteimprove/alfa-result";
+import { Slice } from "@siteimprove/alfa-slice";
+import { Languages } from "./language/data.js";
+/**
+ * @public
+ */
+export class Language {
+    static of(primary, extended = None, script = None, region = None, variants = []) {
+        return new Language(primary, extended, script, region, variants);
+    }
+    _primary;
+    _extended;
+    _script;
+    _region;
+    _variants;
+    constructor(primary, extended, script, region, variants) {
+        this._primary = primary;
+        this._extended = extended;
+        this._script = script;
+        this._region = region;
+        this._variants = variants;
+    }
+    get primary() {
+        return this._primary;
+    }
+    get extended() {
+        return this._extended;
+    }
+    get script() {
+        return this._script;
+    }
+    get region() {
+        return this._region;
+    }
+    get variants() {
+        return this._variants;
+    }
+    equals(value) {
+        return (value instanceof Language &&
+            value._primary.equals(this._primary) &&
+            value._extended.equals(this._extended) &&
+            value._script.equals(this._script) &&
+            value._region.equals(this._region) &&
+            value._variants.length === this._variants.length &&
+            value._variants.every((variant, i) => variant.equals(this._variants[i])));
+    }
+    toJSON() {
+        return {
+            type: "language",
+            primary: this._primary.toJSON(),
+            extended: this._extended.map((extended) => extended.toJSON()).getOr(null),
+            script: this._script.map((script) => script.toJSON()).getOr(null),
+            region: this._region.map((region) => region.toJSON()).getOr(null),
+            variants: this._variants.map((variant) => variant.toJSON()),
+        };
+    }
+    toString() {
+        return [
+            this._primary,
+            ...this._extended,
+            ...this._script,
+            ...this._region,
+            ...this._variants,
+        ].join("-");
+    }
+}
+/**
+ * @public
+ */
+(function (Language) {
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-3.1.2}
+     */
+    class Subtag {
+        _name;
+        constructor(name) {
+            this._name = name;
+        }
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.4}
+         */
+        get name() {
+            return this._name;
+        }
+        toString() {
+            return this._name;
+        }
+    }
+    Language.Subtag = Subtag;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.1}
+     */
+    class Primary extends Subtag {
+        static of(name) {
+            return new Primary(name);
+        }
+        constructor(name) {
+            super(name);
+        }
+        get type() {
+            return "primary";
+        }
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.11}
+         */
+        get scope() {
+            return Option.from(Languages.primary[this._name].scope);
+        }
+        equals(value) {
+            return value instanceof Primary && value._name === this._name;
+        }
+        toJSON() {
+            return {
+                type: "primary",
+                name: this._name,
+                scope: this.scope.getOr(null),
+            };
+        }
+    }
+    Language.Primary = Primary;
+    (function (Primary) {
+        function isPrimary(value) {
+            return value instanceof Primary;
+        }
+        Primary.isPrimary = isPrimary;
+        function isName(name) {
+            return name in Languages.primary;
+        }
+        Primary.isName = isName;
+    })(Primary = Language.Primary || (Language.Primary = {}));
+    Language.primary = Primary.of, Language.isPrimary = Primary.isPrimary, Language.isPrimaryName = Primary.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.2}
+     */
+    class Extended extends Subtag {
+        static of(name) {
+            return new Extended(name);
+        }
+        constructor(name) {
+            super(name);
+        }
+        get type() {
+            return "extended";
+        }
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.8}
+         */
+        get prefix() {
+            return Languages.extended[this._name].prefix;
+        }
+        equals(value) {
+            return value instanceof Extended && value._name === this._name;
+        }
+        toJSON() {
+            return {
+                type: "extended",
+                name: this._name,
+                prefix: this.prefix,
+            };
+        }
+    }
+    Language.Extended = Extended;
+    (function (Extended) {
+        function isExtended(value) {
+            return value instanceof Extended;
+        }
+        Extended.isExtended = isExtended;
+        function isName(name) {
+            return name in Languages.extended;
+        }
+        Extended.isName = isName;
+    })(Extended = Language.Extended || (Language.Extended = {}));
+    Language.extended = Extended.of, Language.isExtended = Extended.isExtended, Language.isExtendedName = Extended.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.3}
+     */
+    class Script extends Subtag {
+        static of(name) {
+            return new Script(name);
+        }
+        constructor(name) {
+            super(name);
+        }
+        get type() {
+            return "script";
+        }
+        equals(value) {
+            return value instanceof Script && value._name === this._name;
+        }
+        toJSON() {
+            return {
+                type: "script",
+                name: this._name,
+            };
+        }
+    }
+    Language.Script = Script;
+    (function (Script) {
+        function isScript(value) {
+            return value instanceof Script;
+        }
+        Script.isScript = isScript;
+        function isName(name) {
+            return name in Languages.script;
+        }
+        Script.isName = isName;
+    })(Script = Language.Script || (Language.Script = {}));
+    Language.script = Script.of, Language.isScript = Script.isScript, Language.isScriptName = Script.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.4}
+     */
+    class Region extends Subtag {
+        static of(name) {
+            return new Region(name);
+        }
+        constructor(name) {
+            super(name);
+        }
+        get type() {
+            return "region";
+        }
+        equals(value) {
+            return value instanceof Region && value._name === this._name;
+        }
+        toJSON() {
+            return {
+                type: "region",
+                name: this._name,
+            };
+        }
+    }
+    Language.Region = Region;
+    (function (Region) {
+        function isRegion(value) {
+            return value instanceof Region;
+        }
+        Region.isRegion = isRegion;
+        function isName(name) {
+            return name in Languages.region;
+        }
+        Region.isName = isName;
+    })(Region = Language.Region || (Language.Region = {}));
+    Language.region = Region.of, Language.isRegion = Region.isRegion, Language.isRegionName = Region.isName;
+    /**
+     * {@link https://tools.ietf.org/html/bcp47#section-2.2.5}
+     */
+    class Variant extends Subtag {
+        static of(name) {
+            return new Variant(name);
+        }
+        constructor(name) {
+            super(name);
+        }
+        get type() {
+            return "variant";
+        }
+        /**
+         * {@link https://tools.ietf.org/html/bcp47#section-3.1.8}
+         */
+        get prefixes() {
+            return Languages.variant[this._name].prefixes;
+        }
+        equals(value) {
+            return value instanceof Variant && value._name === this._name;
+        }
+        toJSON() {
+            return {
+                type: "variant",
+                name: this._name,
+                prefixes: [...this.prefixes],
+            };
+        }
+    }
+    Language.Variant = Variant;
+    (function (Variant) {
+        function isVariant(value) {
+            return value instanceof Variant;
+        }
+        Variant.isVariant = isVariant;
+        function isName(name) {
+            return name in Languages.variant;
+        }
+        Variant.isName = isName;
+    })(Variant = Language.Variant || (Language.Variant = {}));
+    Language.variant = Variant.of, Language.isVariant = Variant.isVariant, Language.isVariantName = Variant.isName;
+})(Language || (Language = {}));
+/**
+ * @public
+ */
+(function (Language) {
+    function parse(input) {
+        let parts = Slice.of(input.toLowerCase().split("-"));
+        return parts
+            .get(0)
+            .map((name) => {
+            if (!Language.isPrimaryName(name)) {
+                return Err.of(`${name} is not a valid primary language`);
+            }
+            const primary = Language.Primary.of(name);
+            parts = parts.slice(1);
+            const extended = parts.get(0).filter(Language.isExtendedName).map(Language.Extended.of);
+            if (extended.isSome()) {
+                parts = parts.slice(1);
+            }
+            const script = parts.get(0).filter(Language.isScriptName).map(Language.Script.of);
+            if (script.isSome()) {
+                parts = parts.slice(1);
+            }
+            const region = parts.get(0).filter(Language.isRegionName).map(Language.Region.of);
+            if (region.isSome()) {
+                parts = parts.slice(1);
+            }
+            const variants = [];
+            while (true) {
+                const variant = parts.get(0).filter(Language.isVariantName).map(Language.Variant.of);
+                if (variant.isSome()) {
+                    parts = parts.slice(1);
+                    variants.push(variant.get());
+                }
+                else {
+                    break;
+                }
+            }
+            return Result.of(Language.of(primary, extended, script, region, variants));
+        })
+            .getOrElse(() => Err.of(`Expected a primary language name`));
+    }
+    Language.parse = parse;
+})(Language || (Language = {}));
+//# sourceMappingURL=language.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-iana",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "Functionality for working with the different IANA registries, such as the language subtag registry",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-iana"
+  },
+  "bugs": "https://github.com/siteimprove/alfa/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "generate": "node scripts/languages.js"
+  },
+  "dependencies": {
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-option": "^0.89.5",
+    "@siteimprove/alfa-result": "^0.89.5",
+    "@siteimprove/alfa-slice": "^0.89.5"
+  },
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5",
+    "axios": "^1.7.4",
+    "prettier": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}