@markuplint/ml-spec 2.0.0-rc.0 → 2.0.0-rc.1

package/src/get-attr-specs.spec.ts

@@ -0,0 +1,44 @@
+import htmlSpec from '@markuplint/html-spec';
+
+import { getAttrSpecs } from './get-attr-specs';
+
+describe('getSpec', () => {
+	test('svg:image[x]', () => {
+		const specs = getAttrSpecs('svg:image', htmlSpec);
+		const x = specs?.find(spec => spec.name === 'x');
+		expect(x).toStrictEqual({
+			ref: 'https://svgwg.org/svg2-draft/geometry.html#XProperty',
+			defaultValue: '0',
+			name: 'x',
+			type: ['<svg-length>', '<percentage>'],
+			animatable: true,
+		});
+	});
+
+	test('svg:foreignObject[x]', () => {
+		const specs = getAttrSpecs('svg:foreignObject', htmlSpec);
+		const x = specs?.find(spec => spec.name === 'x');
+		expect(x).toStrictEqual({
+			ref: 'https://svgwg.org/svg2-draft/geometry.html#XProperty',
+			defaultValue: '0',
+			description:
+				'The x coordinate of the foreignObject. Value type: <length>|<percentage> ; Default value: 0; Animatable: yes',
+			name: 'x',
+			type: ['<svg-length>', '<percentage>'],
+			animatable: true,
+		});
+	});
+
+	test('svg:linearGradient[xlink:href]', () => {
+		const specs = getAttrSpecs('svg:linearGradient', htmlSpec);
+		const x = specs?.find(spec => spec.name === 'xlink:href');
+		expect(x).toStrictEqual({
+			ref: 'https://www.w3.org/TR/xlink11/#link-locators',
+			description:
+				'Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.An <IRI> reference to another <linearGradient> element that will be used as a template. Value type: <IRI> ; Default value: none; Animatable: yes',
+			name: 'xlink:href',
+			type: 'URL',
+			deprecated: true,
+		});
+	});
+});

package/src/get-attr-specs.ts

@@ -0,0 +1,111 @@
+import type { MLMLSpec, Attribute } from './types';
+
+const cacheMap = new Map<string, Attribute[] | null>();
+const schemaCache = new WeakSet<MLMLSpec>();
+
+export function getAttrSpecs(nameWithNS: string, schema: MLMLSpec) {
+	if (!schemaCache.has(schema)) {
+		cacheMap.clear();
+	}
+
+	const cache = cacheMap.get(nameWithNS);
+
+	if (cache !== undefined) {
+		return cache;
+	}
+
+	schemaCache.add(schema);
+
+	const elSpec = schema.specs.find(spec => spec.name === nameWithNS);
+	if (!elSpec) {
+		cacheMap.set(nameWithNS, null);
+		return null;
+	}
+
+	const globalAttrs = schema.def['#globalAttrs'];
+	let attrs: Record<string, Partial<Attribute>> = {};
+
+	for (const catName in elSpec.globalAttrs) {
+		// @ts-ignore
+		const catAttrs: boolean | string[] = elSpec.globalAttrs[catName];
+		if (!catAttrs) {
+			continue;
+		}
+		if (typeof catAttrs === 'boolean') {
+			const global = globalAttrs[catName];
+			attrs = {
+				...attrs,
+				...global,
+			};
+			continue;
+		}
+		if (Array.isArray(catAttrs)) {
+			const global = globalAttrs[catName];
+			if (!global) {
+				continue;
+			}
+			catAttrs.forEach(selectedName => {
+				const selected = global[selectedName];
+				attrs[selectedName] = {
+					...attrs[selectedName],
+					...selected,
+				};
+			});
+			continue;
+		}
+	}
+
+	for (const attrName in elSpec.attributes) {
+		const attr = elSpec.attributes[attrName];
+		if (!attr) {
+			continue;
+		}
+
+		const current = attrs[attrName] as Omit<Attribute, 'name'> | undefined;
+
+		attrs[attrName] = {
+			description: '',
+			...current,
+			...attr,
+		};
+	}
+
+	const attrList: Attribute[] = Object.keys(attrs).map<Attribute>(name => {
+		const attr = attrs[name];
+		return { name, type: 'Any', ...attr };
+	});
+
+	for (const attr of attrList) {
+		if (!attr.type) {
+			throw new Error(
+				`The type is empty in the ${attr.name} attribute of the ${nameWithNS} element,
+					'packages',
+					'@markuplint',
+					'html-spec',
+					'src',
+					'attributes',
+					nameWithNS.replace(':', '_') + '.json',
+				)})`,
+			);
+		}
+	}
+
+	attrList.sort(nameCompare);
+
+	cacheMap.set(nameWithNS, attrList);
+	return attrList;
+}
+
+type HasName = { name: string };
+
+export function nameCompare(a: HasName | string, b: HasName | string) {
+	const nameA = typeof a === 'string' ? a : a.name.toUpperCase();
+	const nameB = typeof b === 'string' ? b : b.name.toUpperCase();
+	if (nameA < nameB) {
+		return -1;
+	}
+	if (nameA > nameB) {
+		return 1;
+	}
+	return 0;
+}

package/src/get-spec-by-tag-name.ts

@@ -1,8 +1,17 @@
-import type { Attribute, MLDOMElementSpec, MLMLSpec, SpecOM } from './types';
+import type { MLDOMElementSpec, MLMLSpec, SpecOM } from './types';
 
-function getSpecOM({ specs }: MLMLSpec): SpecOM {
+import { getAttrSpecs } from './get-attr-specs';
+
+const cacheMap = new WeakMap<MLMLSpec, SpecOM>();
+
+function getSpecOM(spec: MLMLSpec): SpecOM {
+	const cache = cacheMap.get(spec);
+	if (cache) {
+		return cache;
+	}
 	const som: SpecOM = {};
-	for (const el of specs) {
+	for (const el of spec.specs) {
+		const attributes = getAttrSpecs(el.name, spec);
 		som[el.name] = {
 			experimental: !!el.experimental,
 			obsolete: typeof el.obsolete === 'boolean' ? !!el.obsolete : el.obsolete ? el.obsolete.alt : false,
@@ -10,11 +19,10 @@ function getSpecOM({ specs }: MLMLSpec): SpecOM {
 			nonStandard: !!el.nonStandard,
 			categories: el.categories,
 			permittedStructures: el.permittedStructures,
-			attributes: el.attributes.filter(
-				(attr: Attribute | string): attr is Attribute => !(typeof attr === 'string'),
-			),
+			attributes: Object.values(attributes || {}),
 		};
 	}
+	cacheMap.set(spec, som);
 	return som;
 }
 

package/src/get-spec.spec.ts

@@ -1,28 +1,26 @@
-import type { Attribute } from '@markuplint/html-spec';
-
 import htmlSpec from '@markuplint/html-spec';
 
 import { getSpec } from './get-spec';
 
 describe('getSpec', () => {
-	test('', () => {
-		const exAttr: Attribute = {
-			name: 'extended-attr',
+	test('Overriding', () => {
+		const exAttr = {
+			ref: 'N/A',
 			type: 'Boolean',
 			description: 'For the unit test.',
-		};
-		const exAttr2: Attribute = {
-			name: 'extended-attr',
+		} as const;
+		const exAttr2 = {
+			ref: 'N/A',
 			type: 'Boolean',
 			description: 'For the unit test. Override.',
-		};
+		} as const;
 		const mergedSpec = getSpec([
 			htmlSpec,
 			{
 				specs: [
 					{
 						name: 'a',
-						attributes: [exAttr],
+						attributes: { 'extended-attr': exAttr },
 					},
 				],
 			},
@@ -30,17 +28,12 @@ describe('getSpec', () => {
 				specs: [
 					{
 						name: 'a',
-						attributes: [exAttr2],
+						attributes: { 'extended-attr': exAttr2 },
 					},
 				],
 			},
 		]);
 		const aElAttrs = mergedSpec.specs.find(el => el.name === 'a')!.attributes;
-		expect(
-			aElAttrs.find((attr): attr is Attribute => !(typeof attr === 'string') && attr.name === 'href')!.name,
-		).toBe('href');
-		expect(
-			aElAttrs.find((attr): attr is Attribute => !(typeof attr === 'string') && attr.name === exAttr.name),
-		).toStrictEqual(exAttr2);
+		expect(aElAttrs['extended-attr']).toStrictEqual(exAttr2);
 	});
 });

package/src/get-spec.ts

@@ -1,4 +1,4 @@
-import type { ElementSpec, ExtendedSpec, MLMLSpec } from './types';
+import type { ElementSpec, ExtendedSpec, MLMLSpec, Attribute } from './types';
 
 import { mergeArray } from './utils';
 
@@ -21,10 +21,10 @@ export function getSpec(schemas: readonly [MLMLSpec, ...ExtendedSpec[]]) {
 				result.def['#ariaAttrs'] = [...result.def['#ariaAttrs'], ...extendedSpec.def['#ariaAttrs']];
 			}
 			if (extendedSpec.def['#globalAttrs']?.['#extends']) {
-				result.def['#globalAttrs']['#HTMLGlobalAttrs'] = [
-					...(result.def['#globalAttrs']?.['#HTMLGlobalAttrs'] || []),
-					...(extendedSpec.def['#globalAttrs']?.['#extends'] || []),
-				];
+				result.def['#globalAttrs']['#HTMLGlobalAttrs'] = {
+					...(result.def['#globalAttrs']?.['#HTMLGlobalAttrs'] || {}),
+					...(extendedSpec.def['#globalAttrs']?.['#extends'] || {}),
+				};
 			}
 			if (extendedSpec.def['#roles']) {
 				result.def['#roles'] = [...result.def['#roles'], ...extendedSpec.def['#roles']];
@@ -55,7 +55,11 @@ export function getSpec(schemas: readonly [MLMLSpec, ...ExtendedSpec[]]) {
 				specs.push({
 					...elSpec,
 					...exSpec,
-					attributes: mergeArray(elSpec.attributes, exSpec.attributes),
+					globalAttrs: {
+						...elSpec.globalAttrs,
+						...exSpec.globalAttrs,
+					},
+					attributes: mergeAttrSpec(elSpec.attributes, exSpec.attributes),
 					categories: mergeArray(elSpec.categories, exSpec.categories),
 				});
 			}
@@ -66,3 +70,20 @@ export function getSpec(schemas: readonly [MLMLSpec, ...ExtendedSpec[]]) {
 
 	return result;
 }
+
+function mergeAttrSpec(
+	std: Record<string, Attribute>,
+	ex: Record<string, Partial<Attribute>> = {},
+): Record<string, Attribute> {
+	const result: Record<string, Attribute> = {};
+	const keys = Array.from(new Set([...Object.keys(std), ...Object.keys(ex)]));
+	for (const key of keys) {
+		const _std = std[key];
+		const _ex = ex[key];
+		result[key] = {
+			..._std,
+			..._ex,
+		};
+	}
+	return result;
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './permitted-structres';
 export * from './attributes';
+export * from './get-attr-specs';
 export * from './get-spec-by-tag-name';
 export * from './get-spec';
 export * from './get-ns';

package/src/permitted-structres.ts

@@ -57,6 +57,12 @@ export interface PermittedStructuresSchema {
 			  }
 			| {
 					parent: string;
+					/**
+					 * Not support yet
+					 */
+					hasNotAttr?: string;
+					_TODO_?: string;
+					_parent?: string;
 			  };
 		contents: PermittedContentSpec | boolean;
 	}[];
@@ -69,24 +75,28 @@ export interface PermittedContentRequire {
 	notAllowedDescendants?: Node[];
 	max?: number;
 	min?: number;
+	_TODO_?: string;
 }
 export interface PermittedContentOptional {
 	optional: Target;
 	ignore?: Target;
 	notAllowedDescendants?: Node[];
 	max?: number;
+	_TODO_?: string;
 }
 export interface PermittedContentOneOrMore {
 	oneOrMore: Target | PermittedContentSpec;
 	ignore?: Target;
 	notAllowedDescendants?: Node[];
 	max?: number;
+	_TODO_?: string;
 }
 export interface PermittedContentZeroOrMore {
 	zeroOrMore: Target | PermittedContentSpec;
 	ignore?: Target;
 	notAllowedDescendants?: Node[];
 	max?: number;
+	_TODO_?: string;
 }
 export interface PermittedContentChoice {
 	choice:
@@ -100,7 +110,9 @@ export interface PermittedContentChoice {
 				PermittedContentSpec,
 				PermittedContentSpec,
 		  ];
+	_TODO_?: string;
 }
 export interface PermittedContentInterleave {
 	interleave: [PermittedContentSpec, PermittedContentSpec, ...PermittedContentSpec[]];
+	_TODO_?: string;
 }

package/src/types.ts

@@ -1,4 +1,5 @@
-import type { AttributeCondition, AttributeType } from './attributes';
+import type { AttributeJSON } from '.';
+import type { AttributeType, GlobalAttributes } from './attributes';
 import type { ContentModel, PermittedStructuresSchema } from './permitted-structres';
 
 /**
@@ -10,7 +11,10 @@ export interface MLMLSpec {
 	specs: ElementSpec[];
 }
 
-type ExtendedElementSpec = Partial<ElementSpec> & { name: ElementSpec['name'] };
+export type ExtendedElementSpec = Partial<Omit<ElementSpec, 'name' | 'attributes'>> & {
+	name: ElementSpec['name'];
+	attributes?: Record<string, Partial<Attribute>>;
+};
 
 export type ExtendedSpec = {
 	cites?: Cites;
@@ -25,9 +29,9 @@ export type Cites = string[];
 
 export type SpecDefs = {
 	'#globalAttrs': Partial<{
-		'#extends': Attribute[];
-		'#HTMLGlobalAttrs': Attribute[];
-		[OtherGlobalAttrs: string]: Attribute[];
+		'#extends': Record<string, Partial<Attribute>>;
+		'#HTMLGlobalAttrs': Record<string, Partial<Attribute>>;
+		[OtherGlobalAttrs: string]: Record<string, Partial<Attribute>>;
 	}>;
 	'#ariaAttrs': ARIAAttribute[];
 	'#roles': ARIRRoleAttribute[];
@@ -122,10 +126,15 @@ export type ElementSpec = {
 	 */
 	omittion: ElementSpecOmittion;
 
+	/**
+	 * Global Attributes
+	 */
+	globalAttrs: GlobalAttributes;
+
 	/**
 	 * Attributes
 	 */
-	attributes: (Attribute | string)[];
+	attributes: Record<string, Attribute>;
 };
 
 /**
@@ -152,18 +161,16 @@ type ElementCondition = {
 
 export type Attribute = {
 	name: string;
-	type: AttributeType | [AttributeType, ...AttributeType[]];
-	description: string;
+	type: AttributeType | AttributeType[];
+	description?: string;
 	caseSensitive?: true;
 	experimental?: true;
 	obsolete?: true;
 	deprecated?: boolean;
 	nonStandard?: true;
-	required?: boolean | AttributeCondition;
-	requiredEither?: string[];
-	noUse?: boolean;
-	condition?: AttributeCondition;
-};
+} & ExtendableAttributeSpec;
+
+type ExtendableAttributeSpec = Omit<AttributeJSON, 'ref' | '_TODO_' | 'type'>;
 
 export type ARIRRoleAttribute = {
 	name: string;