@markuplint/types 3.0.0-alpha.0 → 3.0.0-alpha.2

package/src/css-syntax.spec.ts

@@ -116,7 +116,7 @@ test('custom-type-checking', () => {
 	expect(cssSyntaxMatch('0', custom).matched).toBe(false);
 });
 
-test('case-sensivite', () => {
+test('case-sensitive', () => {
 	const custom: CustomCssSyntax = {
 		ref: 'n/a',
 		caseSensitive: true,

package/src/defs.ts

@@ -1,7 +1,7 @@
 import type { Defs, CssSyntaxTokenizer } from './types';
 
 import { checkMultiTypes } from './check-multi-types';
-import { getCandicate } from './get-candicate';
+import { getCandidate } from './get-candidate';
 import { matched, matches, unmatched } from './match-result';
 import { splitUnit, isFloat, isUint, isInt } from './primitive';
 import { isBCP47 } from './rfc/is-bcp-47';
@@ -295,8 +295,8 @@ export const types: Defs = {
 				return matched();
 			}
 			if (value[0] === '_') {
-				const candicate = getCandicate(value, keywords);
-				return unmatched(value, 'unexpected-token', { candicate });
+				const candidate = getCandidate(value, keywords);
+				return unmatched(value, 'unexpected-token', { candidate });
 			}
 			return matches(isBrowserContextName())(value);
 		},
@@ -446,7 +446,7 @@ export const types: Defs = {
 			if (value === 'any') {
 				return matched();
 			}
-			const tokens = new TokenCollection(value, { speificSeparator: 'x' });
+			const tokens = new TokenCollection(value, { specificSeparator: 'x' });
 			const [width, sep, height, ...tail] = tokens;
 			if (!width) {
 				return unmatched(value, 'unexpected-token');

package/src/{get-candicate.ts → get-candidate.ts}

@@ -2,23 +2,23 @@ import leven from 'leven';
 
 type NullableString = string | null | undefined;
 
-export function getCandicate(value: NullableString, ...candicates: (NullableString | NullableString[])[]) {
+export function getCandidate(value: NullableString, ...candidates: (NullableString | NullableString[])[]) {
 	if (!value) {
 		return;
 	}
-	const list = candicates.flat(2).filter((s): s is string => !!s);
-	let candicate: string | undefined;
+	const list = candidates.flat(2).filter((s): s is string => !!s);
+	let candidate: string | undefined;
 	let maxRatio = 0;
 	list.forEach(word => {
 		const dist = leven(value.trim().toLowerCase(), word.trim().toLowerCase());
 		const ratio = 1 - dist / word.length;
 		if (0.5 <= ratio && maxRatio < ratio) {
-			candicate = word;
+			candidate = word;
 		}
 		maxRatio = Math.max(ratio, maxRatio);
 	});
-	if (value === candicate) {
+	if (value === candidate) {
 		return;
 	}
-	return candicate;
+	return candidate;
 }

package/src/list.spec.ts

@@ -50,7 +50,7 @@ test('Zero comma (disallowToSurroundBySpaces)', () => {
 test('Location of the token', () => {
 	const type = { token: 'Accept', separator: 'comma' } as const;
 	expect(checkList('x/y;a=b', type)).toStrictEqual({
-		candicate: 'x/y',
+		candidate: 'x/y',
 		column: 4,
 		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
 		length: 4,
@@ -63,7 +63,7 @@ test('Location of the token', () => {
 		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
 	});
 	expect(checkList('x/y,x/y;a=b', type)).toStrictEqual({
-		candicate: 'x/y',
+		candidate: 'x/y',
 		column: 8,
 		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
 		length: 4,
@@ -76,7 +76,7 @@ test('Location of the token', () => {
 		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
 	});
 	expect(checkList('x/y\n,\nx/y;a=b', type)).toStrictEqual({
-		candicate: 'x/y',
+		candidate: 'x/y',
 		column: 4,
 		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
 		length: 4,
@@ -120,7 +120,7 @@ test('Missing comma', () => {
 	const type = { token: 'Accept', separator: 'comma' } as const;
 	expect(checkList('a/b,x/y a/z', type)).toStrictEqual({
 		column: 9,
-		candicate: ',a/z',
+		candidate: ',a/z',
 		expects: undefined,
 		length: 3,
 		line: 1,

package/src/number.ts

@@ -20,25 +20,25 @@ export function checkNumber(value: string, type: Number, ref?: string): Result {
 
 		if (type.gt != null && n <= type.gt) {
 			return unmatched(value, 'out-of-range', {
-				candicate: clampable && isInt ? `${type.gt + 1}` : undefined,
+				candidate: clampable && isInt ? `${type.gt + 1}` : undefined,
 			});
 		}
 
 		if (type.gte != null && n < type.gte) {
 			return unmatched(value, 'out-of-range', {
-				candicate: clampable ? `${type.gte}` : undefined,
+				candidate: clampable ? `${type.gte}` : undefined,
 			});
 		}
 
 		if (type.lt != null && type.lt <= n) {
 			return unmatched(value, 'out-of-range', {
-				candicate: clampable && isInt ? `${type.lt - 1}` : undefined,
+				candidate: clampable && isInt ? `${type.lt - 1}` : undefined,
 			});
 		}
 
 		if (type.lte != null && type.lte < n) {
 			return unmatched(value, 'out-of-range', {
-				candicate: clampable ? `${type.lte}` : undefined,
+				candidate: clampable ? `${type.lte}` : undefined,
 			});
 		}
 	}

package/src/primitive/is-uint.ts

@@ -3,12 +3,12 @@
  *
  * @param value
  */
-export function isUint(value: string, opions?: { gt?: number }) {
+export function isUint(value: string, options?: { gt?: number }) {
 	const matched = /^[0-9]+$/.test(value);
-	if (matched && opions) {
+	if (matched && options) {
 		const n = parseInt(value, 10);
-		if (opions.gt != null) {
-			return isFinite(n) && opions.gt < n;
+		if (options.gt != null) {
+			return isFinite(n) && options.gt < n;
 		}
 	}
 	return matched;

package/src/token/token-collection.spec.ts

@@ -42,7 +42,7 @@ test('parse', () => {
 	]);
 });
 
-test('parse camma separator', () => {
+test('parse comma separator', () => {
 	expect(new TokenCollection('a,, ,b,cde', { separator: 'comma' }).toJSON()).toStrictEqual([
 		{
 			offset: 0,
@@ -87,7 +87,7 @@ test('parse camma separator', () => {
 	]);
 });
 
-test('A camma is an ident if the comma is not a separator', () => {
+test('A comma is an ident if the comma is not a separator', () => {
 	expect(new TokenCollection('a ,cde , f').toJSON()).toStrictEqual([
 		{
 			offset: 0,

package/src/token/token-collection.ts

@@ -7,23 +7,17 @@ import { Token } from './token';
 
 type TokenCollectionOptions = Partial<
 	Omit<List, 'token'> & {
-		speificSeparator: string | string[];
+		specificSeparator: string | string[];
 	}
 >;
 
 export type TokenEachCheck = (head: Token | null, tail: TokenCollection) => Result | void;
 
 export class TokenCollection extends Array<Token> {
-	private static _new(tokens: Token[], old?: TokenCollection) {
-		const newCollection = new TokenCollection('', old);
-		newCollection.push(...tokens);
-		return newCollection;
-	}
-
 	static fromPatterns(
 		value: Token | string,
 		patterns: RegExp[],
-		typeOptions?: Omit<TokenCollectionOptions, 'speificSeparator'> & { repeat?: boolean },
+		typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & { repeat?: boolean },
 	) {
 		const origin = typeof value === 'string' ? value : value.origin;
 		let strings = typeof value === 'string' ? value : value.value;
@@ -40,15 +34,15 @@ export class TokenCollection extends Array<Token> {
 			return token;
 		}
 
-		let isBreaked = false;
+		let isBroken = false;
 		do {
-			isBreaked = false;
+			isBroken = false;
 			for (const pattern of patterns) {
 				const res = pattern.exec(strings);
 				let value: string;
 
 				if (!res) {
-					isBreaked = true;
+					isBroken = true;
 					value = '';
 				} else {
 					if (res.index !== 0) {
@@ -63,7 +57,7 @@ export class TokenCollection extends Array<Token> {
 				// @ts-ignore
 				token._ = pattern;
 			}
-			if (isBreaked) {
+			if (isBroken) {
 				addToken(strings);
 			}
 		} while (typeOptions?.repeat && strings);
@@ -79,13 +73,13 @@ export class TokenCollection extends Array<Token> {
 		return Array;
 	}
 
-	readonly disallowToSurroundBySpaces: NonNullable<List['disallowToSurroundBySpaces']>;
 	readonly allowEmpty: NonNullable<List['allowEmpty']>;
-	readonly ordered: NonNullable<List['ordered']>;
-	readonly unique: NonNullable<List['unique']>;
 	readonly caseInsensitive: NonNullable<List['caseInsensitive']>;
+	readonly disallowToSurroundBySpaces: NonNullable<List['disallowToSurroundBySpaces']>;
 	readonly number: List['number'];
+	readonly ordered: NonNullable<List['ordered']>;
 	readonly separator: NonNullable<List['separator']>;
+	readonly unique: NonNullable<List['unique']>;
 
 	constructor(value?: string, typeOptions?: TokenCollectionOptions);
 	constructor(value?: number); // for map method etc.
@@ -114,11 +108,11 @@ export class TokenCollection extends Array<Token> {
 			separators.push(',');
 		}
 
-		if (typeOptions?.speificSeparator) {
-			if (Array.isArray(typeOptions.speificSeparator)) {
-				separators.push(...typeOptions.speificSeparator);
+		if (typeOptions?.specificSeparator) {
+			if (Array.isArray(typeOptions.specificSeparator)) {
+				separators.push(...typeOptions.specificSeparator);
 			} else {
-				separators.push(typeOptions.speificSeparator);
+				separators.push(typeOptions.specificSeparator);
 			}
 		}
 
@@ -158,62 +152,6 @@ export class TokenCollection extends Array<Token> {
 		return value;
 	}
 
-	filter(callback: (value: Token, index: number, array: Token[]) => boolean) {
-		return TokenCollection._new(super.filter(callback), this);
-	}
-
-	headAndTail(): { head: Token | null; tail: TokenCollection } {
-		const copy = this.slice();
-		const head = copy.shift();
-		if (!head) {
-			return { head: head || null, tail: TokenCollection._new([], this) };
-		}
-		const tail = TokenCollection._new(copy, this);
-		return { head, tail };
-	}
-
-	getIdentTokens() {
-		return this.filter(token => token.type === Token.Ident);
-	}
-
-	compareTokens(callback: (prev: Token, current: Token) => Token | null | void) {
-		const _tokens = this.slice();
-		let prev = _tokens.shift();
-		while (prev) {
-			const current = _tokens.shift();
-			if (!current) {
-				return;
-			}
-			const result = callback(prev, current);
-			if (result) {
-				return result;
-			}
-			prev = current;
-		}
-		return null;
-	}
-
-	/**
-	 *
-	 * @param value The token value or the token type or its list
-	 */
-	has(value: string | RegExp | number | (string | RegExp | number)[]) {
-		return this.some(t => t.match(value));
-	}
-
-	/**
-	 *
-	 * @param value The token value or the token type or its list
-	 */
-	search(value: string | RegExp | number | (string | RegExp | number)[]) {
-		for (const token of this) {
-			if (token.includes(value)) {
-				return token;
-			}
-		}
-		return null;
-	}
-
 	check(options: { expects?: Expect[]; ref?: string; cache?: boolean } = {}) {
 		const { expects, ref } = options;
 
@@ -268,7 +206,7 @@ export class TokenCollection extends Array<Token> {
 					reason: 'missing-comma',
 					ref,
 					expects,
-					candicate: `,${takeTurnsError.token.value}`,
+					candidate: `,${takeTurnsError.token.value}`,
 				});
 			}
 		}
@@ -298,38 +236,42 @@ export class TokenCollection extends Array<Token> {
 		return matched();
 	}
 
-	getConsecutiveToken(tokenType: number) {
-		const resultToken = this.compareTokens((prev, current) => {
-			if (prev.type === tokenType && current.type === tokenType) {
-				return current;
-			}
-		});
-		return resultToken || null;
+	chunk(split: number) {
+		const chunks: TokenCollection[] = [];
+		const tokens = this.slice();
+		while (tokens.length) {
+			const chunkTokens = tokens.splice(0, split);
+			const chunk = TokenCollection._new(chunkTokens, this);
+			chunks.push(chunk);
+		}
+		return chunks;
 	}
 
-	takeTurns(tokenNumbers: ReadonlyArray<number>, lastTokenNumber?: number) {
-		const tokens = this.slice();
-		for (let i = 0; i < tokens.length; i++) {
-			const token = tokens[i];
-			const expectedTokenNumber = tokenNumbers[i % tokenNumbers.length];
-			if (token.type !== expectedTokenNumber) {
-				return {
-					unexpectedLastToken: false,
-					expectedTokenNumber,
-					token,
-				};
+	compareTokens(callback: (prev: Token, current: Token) => Token | null | void) {
+		const _tokens = this.slice();
+		let prev = _tokens.shift();
+		while (prev) {
+			const current = _tokens.shift();
+			if (!current) {
+				return;
 			}
-			if (lastTokenNumber != null && i === tokens.length - 1 && token.type !== lastTokenNumber) {
-				return {
-					unexpectedLastToken: true,
-					expectedTokenNumber,
-					token,
-				};
+			const result = callback(prev, current);
+			if (result) {
+				return result;
 			}
+			prev = current;
 		}
 		return null;
 	}
 
+	divide(position: number) {
+		const _a = this.slice(0, position);
+		const _b = this.slice(position);
+		const a = TokenCollection._new(_a, this);
+		const b = TokenCollection._new(_b, this);
+		return [a, b] as const;
+	}
+
 	eachCheck(...callbacks: TokenEachCheck[]): Result {
 		let headAndTail = this.headAndTail();
 		let head = headAndTail.head;
@@ -397,6 +339,19 @@ export class TokenCollection extends Array<Token> {
 		return matched();
 	}
 
+	filter(callback: (value: Token, index: number, array: Token[]) => boolean) {
+		return TokenCollection._new(super.filter(callback), this);
+	}
+
+	getConsecutiveToken(tokenType: number) {
+		const resultToken = this.compareTokens((prev, current) => {
+			if (prev.type === tokenType && current.type === tokenType) {
+				return current;
+			}
+		});
+		return resultToken || null;
+	}
+
 	getDuplicated() {
 		const aList = this.slice();
 		const bList = this.slice();
@@ -419,26 +374,71 @@ export class TokenCollection extends Array<Token> {
 		return null;
 	}
 
-	divide(position: number) {
-		const _a = this.slice(0, position);
-		const _b = this.slice(position);
-		const a = TokenCollection._new(_a, this);
-		const b = TokenCollection._new(_b, this);
-		return [a, b] as const;
+	getIdentTokens() {
+		return this.filter(token => token.type === Token.Ident);
 	}
 
-	chunk(split: number) {
-		const chunks: TokenCollection[] = [];
+	/**
+	 *
+	 * @param value The token value or the token type or its list
+	 */
+	has(value: string | RegExp | number | (string | RegExp | number)[]) {
+		return this.some(t => t.match(value));
+	}
+
+	headAndTail(): { head: Token | null; tail: TokenCollection } {
+		const copy = this.slice();
+		const head = copy.shift();
+		if (!head) {
+			return { head: head || null, tail: TokenCollection._new([], this) };
+		}
+		const tail = TokenCollection._new(copy, this);
+		return { head, tail };
+	}
+
+	/**
+	 *
+	 * @param value The token value or the token type or its list
+	 */
+	search(value: string | RegExp | number | (string | RegExp | number)[]) {
+		for (const token of this) {
+			if (token.includes(value)) {
+				return token;
+			}
+		}
+		return null;
+	}
+
+	takeTurns(tokenNumbers: ReadonlyArray<number>, lastTokenNumber?: number) {
 		const tokens = this.slice();
-		while (tokens.length) {
-			const chunkTokens = tokens.splice(0, split);
-			const chunk = TokenCollection._new(chunkTokens, this);
-			chunks.push(chunk);
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			const expectedTokenNumber = tokenNumbers[i % tokenNumbers.length];
+			if (token.type !== expectedTokenNumber) {
+				return {
+					unexpectedLastToken: false,
+					expectedTokenNumber,
+					token,
+				};
+			}
+			if (lastTokenNumber != null && i === tokens.length - 1 && token.type !== lastTokenNumber) {
+				return {
+					unexpectedLastToken: true,
+					expectedTokenNumber,
+					token,
+				};
+			}
 		}
-		return chunks;
+		return null;
 	}
 
 	toJSON() {
 		return this.map(t => t.toJSON());
 	}
+
+	private static _new(tokens: Token[], old?: TokenCollection) {
+		const newCollection = new TokenCollection('', old);
+		newCollection.push(...tokens);
+		return newCollection;
+	}
 }

package/src/token/token.ts

@@ -1,6 +1,34 @@
 import type { UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from '../types';
 
 export class Token {
+	/**
+	 * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
+	 */
+	static readonly Comma = 18;
+	static readonly Ident = 1;
+	static readonly WhiteSpace = 13;
+
+	/**
+	 * ASCII whitespace is
+	 * - U+0009 TAB
+	 * - U+000A LF
+	 * - U+000C FF
+	 * - U+000D CR
+	 * - U+0020 SPACE.
+	 *
+	 * @see https://infra.spec.whatwg.org/#ascii-whitespace
+	 */
+	static readonly whitespace: ReadonlyArray<string> = ['\u0009', '\u000A', '\u000C', '\u000D', '\u0020'];
+
+	static getCol(value: string, offset: number) {
+		const lines = value.slice(0, offset).split(/\n/g);
+		return lines[lines.length - 1].length + 1;
+	}
+
+	static getLine(value: string, offset: number) {
+		return value.slice(0, offset).split(/\n/g).length;
+	}
+
 	static getType(value: string, separators?: string[]) {
 		if (Token.whitespace.includes(value[0])) {
 			return Token.WhiteSpace;
@@ -14,15 +42,6 @@ export class Token {
 		return Token.Ident;
 	}
 
-	static getLine(value: string, offset: number) {
-		return value.slice(0, offset).split(/\n/g).length;
-	}
-
-	static getCol(value: string, offset: number) {
-		const lines = value.slice(0, offset).split(/\n/g);
-		return lines[lines.length - 1].length + 1;
-	}
-
 	static shiftLocation(token: Token, offset: number) {
 		const shifted = token.offset + offset;
 		return {
@@ -32,29 +51,10 @@ export class Token {
 		};
 	}
 
-	/**
-	 * ASCII whitespace is
-	 * - U+0009 TAB
-	 * - U+000A LF
-	 * - U+000C FF
-	 * - U+000D CR
-	 * - U+0020 SPACE.
-	 *
-	 * @see https://infra.spec.whatwg.org/#ascii-whitespace
-	 */
-	static readonly whitespace: ReadonlyArray<string> = ['\u0009', '\u000A', '\u000C', '\u000D', '\u0020'];
-
-	/**
-	 * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
-	 */
-	static readonly Ident = 1;
-	static readonly WhiteSpace = 13;
-	static readonly Comma = 18;
-
-	readonly type: number;
-	readonly value: string;
 	readonly offset: number;
 	#originalValue: string;
+	readonly type: number;
+	readonly value: string;
 
 	constructor(value: string, offset: number, originalValue: string, separators?: string[]) {
 		this.type = Token.getType(value, separators);
@@ -71,37 +71,18 @@ export class Token {
 		return this.#originalValue;
 	}
 
-	unmatched(
-		options?: UnmatchedResultOptions & {
-			ref?: string;
-			reason?: UnmatchedResultReason;
-		},
-	): UnmatchedResult {
-		return {
-			...options,
-			matched: false,
-			ref: options?.ref || null,
-			raw: this.value,
-			offset: this.offset,
-			length: this.value.length,
-			line: Token.getLine(this.#originalValue, this.offset),
-			column: Token.getCol(this.#originalValue, this.offset),
-			reason: options?.reason ?? 'syntax-error',
-		};
-	}
-
 	/**
 	 *
 	 * @param value The token value or the token type or its list
 	 */
-	match(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean {
+	includes(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean {
 		if (Array.isArray(value)) {
-			return value.some(v => this.match(v));
+			return value.some(v => this.includes(v));
 		}
 		if (typeof value === 'string') {
 			const a = caseInsensitive ? this.value.toLowerCase() : this.value;
 			const b = caseInsensitive ? value.toLowerCase() : value;
-			return a === b;
+			return a.indexOf(b) !== -1;
 		}
 		if (value instanceof RegExp) {
 			const pattern = new RegExp(value, caseInsensitive ? 'i' : '');
@@ -114,14 +95,14 @@ export class Token {
 	 *
 	 * @param value The token value or the token type or its list
 	 */
-	includes(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean {
+	match(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean {
 		if (Array.isArray(value)) {
-			return value.some(v => this.includes(v));
+			return value.some(v => this.match(v));
 		}
 		if (typeof value === 'string') {
 			const a = caseInsensitive ? this.value.toLowerCase() : this.value;
 			const b = caseInsensitive ? value.toLowerCase() : value;
-			return a.indexOf(b) !== -1;
+			return a === b;
 		}
 		if (value instanceof RegExp) {
 			const pattern = new RegExp(value, caseInsensitive ? 'i' : '');
@@ -130,15 +111,34 @@ export class Token {
 		return this.type === value;
 	}
 
+	toJSON() {
+		return {
+			type: this.type,
+			value: this.value,
+			offset: this.offset,
+		};
+	}
+
 	toNumber() {
 		return parseFloat(this.value);
 	}
 
-	toJSON() {
+	unmatched(
+		options?: UnmatchedResultOptions & {
+			ref?: string;
+			reason?: UnmatchedResultReason;
+		},
+	): UnmatchedResult {
 		return {
-			type: this.type,
-			value: this.value,
+			...options,
+			matched: false,
+			ref: options?.ref || null,
+			raw: this.value,
 			offset: this.offset,
+			length: this.value.length,
+			line: Token.getLine(this.#originalValue, this.offset),
+			column: Token.getCol(this.#originalValue, this.offset),
+			reason: options?.reason ?? 'syntax-error',
 		};
 	}
 }

package/src/types.schema.ts

@@ -1037,6 +1037,9 @@ export interface List {
  * [Enumerated attributes](https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#enumerated-attribute)
  */
 export interface Enum {
+	/**
+	 * @minItems 1
+	 */
 	enum: [string, ...string[]];
 	disallowToSurroundBySpaces?: boolean;
 	caseInsensitive?: boolean;