@markuplint/ml-spec 3.0.0-alpha.82 → 3.0.0-dev.176

package/lib/types/index.d.ts

@@ -1,194 +1,223 @@
 import type { ARIA } from './aria';
 import type { AttributeJSON, AttributeType, GlobalAttributes } from './attributes';
-import type { ContentModel, Category } from './permitted-structres';
+import type { ContentModel, Category } from './permitted-structures';
+import type { ariaVersions } from '../constant/aria-version';
 import type { NamespaceURI } from '@markuplint/ml-ast';
+import type { ReadonlyDeep } from 'type-fest';
 /**
- * markuplit Markup-language spec
+ * markuplint Markup-language spec
  */
 export interface MLMLSpec {
-    cites: Cites;
-    def: SpecDefs;
-    specs: ElementSpec[];
+	readonly cites: Cites;
+	readonly def: SpecDefs;
+	readonly specs: readonly ElementSpec[];
 }
-export declare type ExtendedElementSpec = Partial<Omit<ElementSpec, 'name' | 'attributes'>> & {
-    name: ElementSpec['name'];
-    attributes?: Record<string, Partial<Attribute>>;
+export type ExtendedElementSpec = Partial<Omit<ElementSpec, 'name' | 'attributes'>> & {
+	readonly name: ElementSpec['name'];
+	readonly attributes?: Readonly<Record<string, Partial<Attribute>>>;
 };
-export declare type ExtendedSpec = {
-    cites?: Cites;
-    def?: Partial<SpecDefs>;
-    specs?: ExtendedElementSpec[];
+export type ExtendedSpec = {
+	readonly cites?: Cites;
+	readonly def?: Partial<SpecDefs>;
+	readonly specs?: readonly ExtendedElementSpec[];
 };
 /**
  * Reference URLs
  */
-export declare type Cites = string[];
-export declare type SpecDefs = {
-    '#globalAttrs': Partial<{
-        '#extends': Record<string, Partial<Attribute>>;
-        '#HTMLGlobalAttrs': Record<string, Partial<Attribute>>;
-        [OtherGlobalAttrs: string]: Record<string, Partial<Attribute>>;
-    }>;
-    '#aria': {
-        '1.2': ARIASpec;
-        '1.1': ARIASpec;
-    };
-    '#contentModels': {
-        [model in Category]?: string[];
-    };
+export type Cites = readonly string[];
+export type SpecDefs = {
+	readonly '#globalAttrs': {
+		readonly [category: string]: Readonly<Record<string, Partial<Attribute>>>;
+	};
+	readonly '#aria': {
+		readonly '1.3': ARIASpec;
+		readonly '1.2': ARIASpec;
+		readonly '1.1': ARIASpec;
+	};
+	readonly '#contentModels': {
+		readonly [model in Category]?: readonly string[];
+	};
 };
-declare type ARIASpec = {
-    roles: ARIARoleInSchema[];
-    graphicsRoles: ARIARoleInSchema[];
-    props: ARIAProperty[];
+type ARIASpec = {
+	readonly roles: readonly ARIARoleInSchema[];
+	readonly graphicsRoles: readonly ARIARoleInSchema[];
+	readonly props: readonly ARIAProperty[];
 };
 /**
  * Element spec
  */
-export declare type ElementSpec = {
-    /**
-     * Tag name
-     */
-    name: string;
-    /**
-     * Namespaces in XML
-     * @see https://www.w3.org/TR/xml-names/
-     */
-    namespace?: NamespaceURI;
-    /**
-     * Reference URL
-     */
-    cite: string;
-    /**
-     * Description
-     */
-    description?: string;
-    /**
-     * Experimental technology
-     */
-    experimental?: true;
-    /**
-     * Obsolete or alternative elements
-     */
-    obsolete?: true | {
-        alt: string;
-    };
-    /**
-     * Deprecated
-     */
-    deprecated?: true;
-    /**
-     * Non-standard
-     */
-    nonStandard?: true;
-    /**
-     * Element cateogries
-     */
-    categories: Category[];
-    /**
-     * Permitted contents and permitted parents
-     */
-    contentModel: ContentModel;
-    /**
-     * Tag omittion
-     */
-    omittion: ElementSpecOmittion;
-    /**
-     * Global Attributes
-     */
-    globalAttrs: GlobalAttributes;
-    /**
-     * Attributes
-     */
-    attributes: Record<string, Attribute>;
-    /**
-     * WAI-ARIA role and properies
-     */
-    aria: ARIA;
-    /**
-     * If true, it is possible to add any properties as attributes,
-     * for example, when using a template engine or a view language.
-     *
-     * @see https://v2.vuejs.org/v2/guide/components-slots.html#Scoped-Slots
-     *
-     * **It assumes to specify it on the parser plugin.**
-     */
-    possibleToAddProperties?: true;
+export type ElementSpec = {
+	/**
+	 * Tag name
+	 */
+	readonly name: string;
+	/**
+	 * Namespaces in XML
+	 * @see https://www.w3.org/TR/xml-names/
+	 */
+	readonly namespace?: NamespaceURI;
+	/**
+	 * Reference URL
+	 */
+	readonly cite: string;
+	/**
+	 * Description
+	 */
+	readonly description?: string;
+	/**
+	 * Experimental technology
+	 */
+	readonly experimental?: true;
+	/**
+	 * Obsolete or alternative elements
+	 */
+	readonly obsolete?:
+		| true
+		| {
+				readonly alt: string;
+		  };
+	/**
+	 * Deprecated
+	 */
+	readonly deprecated?: true;
+	/**
+	 * Non-standard
+	 */
+	readonly nonStandard?: true;
+	/**
+	 * Element categories
+	 */
+	readonly categories: readonly Category[];
+	/**
+	 * Permitted contents and permitted parents
+	 */
+	readonly contentModel: ReadonlyDeep<ContentModel>;
+	/**
+	 * Tag omission
+	 */
+	readonly omission: ElementSpecOmission;
+	/**
+	 * Global Attributes
+	 */
+	readonly globalAttrs: ReadonlyDeep<GlobalAttributes>;
+	/**
+	 * Attributes
+	 */
+	readonly attributes: Readonly<Record<string, Attribute>>;
+	/**
+	 * WAI-ARIA role and properties
+	 */
+	readonly aria: ReadonlyDeep<ARIA>;
+	/**
+	 * If true, it is possible to add any properties as attributes,
+	 * for example, when using a template engine or a view language.
+	 *
+	 * @see https://v2.vuejs.org/v2/guide/components-slots.html#Scoped-Slots
+	 *
+	 * **It assumes to specify it on the parser plugin.**
+	 */
+	readonly possibleToAddProperties?: true;
 };
-declare type ElementSpecOmittion = false | ElementSpecOmittionTags;
-declare type ElementSpecOmittionTags = {
-    startTag: boolean | ElementCondition;
-    endTag: boolean | ElementCondition;
+type ElementSpecOmission = false | ElementSpecOmissionTags;
+type ElementSpecOmissionTags = {
+	readonly startTag: boolean | ElementCondition;
+	readonly endTag: boolean | ElementCondition;
 };
-declare type ElementCondition = {
-    __WIP__: 'WORK_IN_PROGRESS';
+type ElementCondition = {
+	readonly __WIP__: 'WORK_IN_PROGRESS';
 };
-export declare type Attribute = {
-    name: string;
-    type: AttributeType | AttributeType[];
-    description?: string;
-    caseSensitive?: true;
-    experimental?: boolean;
-    obsolete?: true;
-    deprecated?: boolean;
-    nonStandard?: true;
+export type Attribute = {
+	readonly name: string;
+	readonly type: ReadonlyDeep<AttributeType> | readonly ReadonlyDeep<AttributeType>[];
+	readonly description?: string;
+	readonly caseSensitive?: true;
+	readonly experimental?: boolean;
+	readonly obsolete?: true;
+	readonly deprecated?: boolean;
+	readonly nonStandard?: true;
 } & ExtendableAttributeSpec;
-declare type ExtendableAttributeSpec = Omit<AttributeJSON, 'type'>;
-export declare type ARIARole = {
-    name: string;
-    isAbstract: boolean;
-    requiredContextRole: string[];
-    requiredOwnedElements: string[];
-    accessibleNameRequired: boolean;
-    accessibleNameFromAuthor: boolean;
-    accessibleNameFromContent: boolean;
-    accessibleNameProhibited: boolean;
-    childrenPresentational: boolean;
-    ownedProperties: ARIARoleOwnedProperties[];
-    prohibitedProperties: string[];
+type ExtendableAttributeSpec = Omit<ReadonlyDeep<AttributeJSON>, 'type'>;
+export type ARIARole = {
+	readonly name: string;
+	readonly isAbstract: boolean;
+	readonly requiredContextRole: readonly string[];
+	readonly requiredOwnedElements: readonly string[];
+	readonly accessibleNameRequired: boolean;
+	readonly accessibleNameFromAuthor: boolean;
+	readonly accessibleNameFromContent: boolean;
+	readonly accessibleNameProhibited: boolean;
+	readonly childrenPresentational: boolean;
+	readonly ownedProperties: readonly ARIARoleOwnedProperties[];
+	readonly prohibitedProperties: readonly string[];
 };
-export declare type ARIARoleInSchema = Partial<ARIARole & {
-    description: string;
-    generalization: string[];
-}> & {
-    name: string;
+export type ARIARoleInSchema = Partial<
+	ARIARole & {
+		readonly description: string;
+		readonly generalization: readonly string[];
+	}
+> & {
+	readonly name: string;
 };
-export declare type ARIARoleOwnedProperties = {
-    name: string;
-    inherited?: true;
-    required?: true;
-    deprecated?: true;
+export type ARIARoleOwnedProperties = {
+	readonly name: string;
+	readonly inherited?: true;
+	readonly required?: true;
+	readonly deprecated?: true;
 };
-export declare type ARIAProperty = {
-    name: string;
-    type: 'property' | 'state';
-    deprecated?: true;
-    isGlobal?: true;
-    value: ARIAAttributeValue;
-    conditionalValue?: {
-        role: string[];
-        value: ARIAAttributeValue;
-    }[];
-    enum: string[];
-    defaultValue?: string;
-    equivalentHtmlAttrs?: EquivalentHtmlAttr[];
-    valueDescriptions?: Record<string, string>;
+export type ARIAProperty = {
+	readonly name: string;
+	readonly type: 'property' | 'state';
+	readonly deprecated?: true;
+	readonly isGlobal?: true;
+	readonly value: ARIAAttributeValue;
+	readonly conditionalValue?: readonly {
+		readonly role: readonly string[];
+		readonly value: ARIAAttributeValue;
+	}[];
+	readonly enum: readonly string[];
+	readonly defaultValue?: string;
+	readonly equivalentHtmlAttrs?: readonly EquivalentHtmlAttr[];
+	readonly valueDescriptions?: Readonly<Record<string, string>>;
 };
-export declare type ARIAAttributeValue = 'true/false' | 'tristate' | 'true/false/undefined' | 'ID reference' | 'ID reference list' | 'integer' | 'number' | 'string' | 'token' | 'token list' | 'URI';
-export declare type ARIAVersion = '1.1' | '1.2';
-export declare type EquivalentHtmlAttr = {
-    htmlAttrName: string;
-    isNotStrictEquivalent?: true;
-    value: string | null;
+export type ARIAAttributeValue =
+	| 'true/false'
+	| 'tristate'
+	| 'true/false/undefined'
+	| 'ID reference'
+	| 'ID reference list'
+	| 'integer'
+	| 'number'
+	| 'string'
+	| 'token'
+	| 'token list'
+	| 'URI';
+export type ARIAVersion = (typeof ariaVersions)[number];
+export type EquivalentHtmlAttr = {
+	readonly htmlAttrName: string;
+	readonly isNotStrictEquivalent?: true;
+	readonly value: string | null;
 };
-export declare type Matches = (selector: string) => boolean;
-export declare type ComputedRole = {
-    el: Element;
-    role: (ARIARole & {
-        superClassRoles: ARIARoleInSchema[];
-        isImplicit?: boolean;
-    }) | null;
-    errorType?: RoleComputationError;
+export type Matches = (selector: string) => boolean;
+export type ComputedRole = {
+	readonly el: Element;
+	readonly role:
+		| (ARIARole & {
+				readonly superClassRoles: readonly ARIARoleInSchema[];
+				readonly isImplicit?: boolean;
+		  })
+		| null;
+	readonly errorType?: RoleComputationError;
 };
-export declare type RoleComputationError = 'ABSTRACT' | 'GLOBAL_PROP_MUST_NOT_BE_PRESENTATIONAL' | 'IMPLICIT_ROLE_NAMESPACE_ERROR' | 'INTERACTIVE_ELEMENT_MUST_NOT_BE_PRESENTATIONAL' | 'INVALID_LANDMARK' | 'INVALID_REQUIRED_CONTEXT_ROLE' | 'NO_EXPLICIT' | 'NO_OWNER' | 'NO_PERMITTED' | 'REQUIRED_OWNED_ELEMENT_MUST_NOT_BE_PRESENTATIONAL' | 'ROLE_NO_EXISTS';
+export type RoleComputationError =
+	| 'ABSTRACT'
+	| 'GLOBAL_PROP_MUST_NOT_BE_PRESENTATIONAL'
+	| 'IMPLICIT_ROLE_NAMESPACE_ERROR'
+	| 'INTERACTIVE_ELEMENT_MUST_NOT_BE_PRESENTATIONAL'
+	| 'INVALID_LANDMARK'
+	| 'INVALID_REQUIRED_CONTEXT_ROLE'
+	| 'NO_EXPLICIT'
+	| 'NO_OWNER'
+	| 'NO_PERMITTED'
+	| 'REQUIRED_OWNED_ELEMENT_MUST_NOT_BE_PRESENTATIONAL'
+	| 'ROLE_NO_EXISTS';
 export {};

package/{src/types/permitted-structres.ts → lib/types/permitted-structures.d.ts}

@@ -1,18 +1,16 @@
-/* tslint:disable */
 /**
  * This file was automatically generated by json-schema-to-typescript.
  * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
  * and run json-schema-to-typescript to regenerate this file.
  */
-
-export type PermittedContent =
+export type PermittedContentPattern =
 	| PermittedContentRequire
 	| PermittedContentOptional
 	| PermittedContentOneOrMore
 	| PermittedContentZeroOrMore
 	| PermittedContentChoice
-	| PermittedContentInterleave;
-export type Target = ContentType | ContentType[];
+	| PermittedContentTransparent;
+export type Model = ContentType | ContentType[];
 export type ContentType = string | Category;
 export type Category =
 	| '#text'
@@ -22,7 +20,6 @@ export type Category =
 	| '#heading'
 	| '#sectioning'
 	| '#metadata'
-	| '#transparent'
 	| '#embedded'
 	| '#palpable'
 	| '#script-supporting'
@@ -44,65 +41,57 @@ export type Category =
 	| '#SVGStructural'
 	| '#SVGStructurallyExternal'
 	| '#SVGTextContent'
-	| '#SVGTextContentChild'
-	| '#SVGOtherXMLNamespace';
-export type PermittedContentSpec = PermittedContent[];
-
+	| '#SVGTextContentChild';
 export interface ContentModelsSchema {
 	__contentModel?: ContentModel;
 }
 export interface ContentModel {
-	contents: PermittedContentSpec | boolean;
+	contents: PermittedContentPattern[] | boolean;
 	descendantOf?: string;
 	conditional?: {
 		condition: string;
-		contents: PermittedContentSpec | boolean;
+		contents: PermittedContentPattern[] | boolean;
 	}[];
 }
 export interface PermittedContentRequire {
-	require: Target;
-	ignore?: Target;
-	notAllowedDescendants?: ContentType[];
+	require: Model | PermittedContentPattern[];
 	max?: number;
 	min?: number;
 	_TODO_?: string;
 }
 export interface PermittedContentOptional {
-	optional: Target;
-	ignore?: Target;
-	notAllowedDescendants?: ContentType[];
+	optional: Model | PermittedContentPattern[];
 	max?: number;
 	_TODO_?: string;
 }
 export interface PermittedContentOneOrMore {
-	oneOrMore: Target | PermittedContentSpec;
-	ignore?: Target;
-	notAllowedDescendants?: ContentType[];
+	oneOrMore: Model | PermittedContentPattern[];
 	max?: number;
 	_TODO_?: string;
 }
 export interface PermittedContentZeroOrMore {
-	zeroOrMore: Target | PermittedContentSpec;
-	ignore?: Target;
-	notAllowedDescendants?: ContentType[];
+	zeroOrMore: Model | PermittedContentPattern[];
 	max?: number;
 	_TODO_?: string;
 }
 export interface PermittedContentChoice {
+	/**
+	 * @minItems 2
+	 * @maxItems 5
+	 */
 	choice:
-		| [PermittedContentSpec, PermittedContentSpec]
-		| [PermittedContentSpec, PermittedContentSpec, PermittedContentSpec]
-		| [PermittedContentSpec, PermittedContentSpec, PermittedContentSpec, PermittedContentSpec]
+		| [PermittedContentPattern[], PermittedContentPattern[]]
+		| [PermittedContentPattern[], PermittedContentPattern[], PermittedContentPattern[]]
+		| [PermittedContentPattern[], PermittedContentPattern[], PermittedContentPattern[], PermittedContentPattern[]]
 		| [
-				PermittedContentSpec,
-				PermittedContentSpec,
-				PermittedContentSpec,
-				PermittedContentSpec,
-				PermittedContentSpec,
+				PermittedContentPattern[],
+				PermittedContentPattern[],
+				PermittedContentPattern[],
+				PermittedContentPattern[],
+				PermittedContentPattern[],
 		  ];
 	_TODO_?: string;
 }
-export interface PermittedContentInterleave {
-	interleave: [PermittedContentSpec, PermittedContentSpec, ...PermittedContentSpec[]];
-	_TODO_?: string;
+export interface PermittedContentTransparent {
+	transparent: string;
 }

package/lib/utils/get-ns.d.ts

@@ -1 +1,2 @@
-export declare function getNS(namespaceURI: string | null): "svg" | "mml" | "html";
+import type { Namespace } from '@markuplint/ml-ast';
+export declare function getNS(namespaceURI: string | null): Namespace;

package/lib/utils/get-ns.js

@@ -9,6 +9,9 @@ function getNS(namespaceURI) {
         case 'http://www.w3.org/1998/Math/MathML': {
             return 'mml';
         }
+        case 'http://www.w3.org/1999/xlink': {
+            return 'xlink';
+        }
         default: {
             return 'html';
         }

package/lib/utils/merge-array.d.ts

@@ -1,5 +1,10 @@
-declare type NamedDefinition = string | {
-    name: string;
-};
-export declare function mergeArray<T extends NamedDefinition>(a: T[], b: T[] | null | undefined): T[];
+type NamedDefinition =
+	| string
+	| {
+			readonly name: string;
+	  };
+export declare function mergeArray<T extends NamedDefinition>(
+	a: readonly T[],
+	b: readonly T[] | null | undefined,
+): readonly T[];
 export {};

package/lib/utils/resolve-namespace.d.ts

@@ -1,9 +1,9 @@
-import type { NamespaceURI } from '@markuplint/ml-ast';
-declare type NamespacedElementName = {
-    localNameWithNS: string;
-    localName: string;
-    namespace: 'html' | 'svg' | 'mml';
-    namespaceURI: NamespaceURI;
+import type { NamespaceURI, Namespace } from '@markuplint/ml-ast';
+type NamespacedElementName = {
+	localNameWithNS: string;
+	localName: string;
+	namespace: Namespace;
+	namespaceURI: NamespaceURI;
 };
-export declare function resolveNamespace(localName: string, namespaceURI?: string | null): NamespacedElementName;
+export declare function resolveNamespace(name: string, namespaceURI?: string | null): NamespacedElementName;
 export {};

package/lib/utils/resolve-namespace.js

@@ -3,24 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNamespace = void 0;
 const get_ns_1 = require("./get-ns");
 const cache = new Map();
-function resolveNamespace(localName, namespaceURI = 'http://www.w3.org/1999/xhtml') {
-    const cached = cache.get(localName + namespaceURI);
+const namespaceURIMap = {
+    html: 'http://www.w3.org/1999/xhtml',
+    svg: 'http://www.w3.org/2000/svg',
+    mml: 'http://www.w3.org/1998/Math/MathML',
+    xlink: 'http://www.w3.org/1999/xlink',
+};
+function resolveNamespace(name, namespaceURI = 'http://www.w3.org/1999/xhtml') {
+    var _a;
+    const cached = cache.get(name + namespaceURI);
     if (cached) {
         return cached;
     }
-    const name = localName.split(':')[1] || localName;
-    const ns = (0, get_ns_1.getNS)(namespaceURI || null);
+    const [_explicitNS, _localName] = name.split(':');
+    const explicitNS = _localName ? _explicitNS : null;
+    const localName = (_a = _localName !== null && _localName !== void 0 ? _localName : _explicitNS) !== null && _a !== void 0 ? _a : '';
+    const namespace = ['html', 'svg', 'mml', 'xlink'].find(_ns => _ns === (explicitNS || (0, get_ns_1.getNS)(namespaceURI !== null && namespaceURI !== void 0 ? namespaceURI : null))) ||
+        'html';
     const result = {
-        localNameWithNS: `${ns === 'html' ? '' : `${ns}:`}${name}`,
-        localName: name,
-        namespace: ns,
-        namespaceURI: [
-            'http://www.w3.org/1999/xhtml',
-            'http://www.w3.org/2000/svg',
-            'http://www.w3.org/1998/Math/MathML',
-        ].find(ns => ns === namespaceURI) || 'http://www.w3.org/1999/xhtml',
+        localNameWithNS: `${namespace === 'html' ? '' : `${namespace}:`}${localName}`,
+        localName,
+        namespace,
+        namespaceURI: namespaceURIMap[namespace],
     };
-    cache.set(localName + namespaceURI, result);
+    cache.set(name + namespaceURI, result);
     return result;
 }
 exports.resolveNamespace = resolveNamespace;

package/lib/utils/validateAriaVersion.d.ts

@@ -0,0 +1,2 @@
+import type { ARIAVersion } from '../types';
+export declare function validateAriaVersion(version: string): version is ARIAVersion;

package/lib/utils/validateAriaVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAriaVersion = void 0;
+const aria_version_1 = require("../constant/aria-version");
+function validateAriaVersion(version) {
+    return aria_version_1.ariaVersions.includes(version);
+}
+exports.validateAriaVersion = validateAriaVersion;