@markuplint/types 1.0.0-dev.20211213.0

package/src/enum.ts

@@ -0,0 +1,25 @@
+import type { Result } from './types';
+import type { Enum } from './types.schema';
+
+import { matched, unmatched } from './match-result';
+
+export function checkEnum(value: string, type: Enum, ref?: string): Result {
+	const disallowToSurroundBySpaces = type.disallowToSurroundBySpaces ?? true;
+	const caseInsensitive = type.caseInsensitive ?? true;
+	if (!disallowToSurroundBySpaces) {
+		value = value.trim();
+	}
+	let values: string[] = type.enum;
+	if (caseInsensitive) {
+		value = value.toLowerCase();
+		values = type.enum.map(v => v.toLowerCase());
+	}
+	const res = values.includes(value);
+	if (res) {
+		return matched();
+	}
+	return unmatched(value, 'doesnt-exist-in-enum', {
+		ref,
+		expects: type.enum.map(value => ({ type: 'const', value })),
+	});
+}

package/src/get-candicate.ts

@@ -0,0 +1,24 @@
+import leven from 'leven';
+
+type NullableString = string | null | undefined;
+
+export function getCandicate(value: NullableString, ...candicates: (NullableString | NullableString[])[]) {
+	if (!value) {
+		return;
+	}
+	const list = candicates.flat(2).filter((s): s is string => !!s);
+	let candicate: 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;
+		}
+		maxRatio = Math.max(ratio, maxRatio);
+	});
+	if (value === candicate) {
+		return;
+	}
+	return candicate;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './whatwg/is-custom-element-name';
+export * from './check';
+export * from './types';

package/src/keyword-type.ts

@@ -0,0 +1,52 @@
+import type { Result } from './types';
+import type { KeywordDefinedType, CssSyntax } from './types.schema';
+
+import { isCSSSyntax } from './check';
+import { cssSyntaxMatch } from './css-syntax';
+import { log } from './debug';
+import { types } from './defs';
+
+const resultCache = new Map<string, Result>();
+const CACHE_KEY_PREFIX = '@markuplint/types/checkKeywordType/cache:::';
+
+export function checkKeywordType(value: string, type: KeywordDefinedType, cache = true) {
+	const key = `${CACHE_KEY_PREFIX}${value}${type}`;
+	if (cache) {
+		const cachedResult = resultCache.get(key);
+		if (cachedResult) {
+			log('Restore cache: %s / %s', value, type);
+			return cachedResult;
+		}
+	}
+	const result = _checkKeywordType(value, type);
+
+	if (cache) {
+		resultCache.set(key, result);
+		log('Cache checking: %O', {
+			input: value,
+			type,
+			key,
+			result: result,
+		});
+	}
+
+	return result;
+}
+
+function _checkKeywordType(value: string, type: KeywordDefinedType): Result {
+	const def = types[type];
+	if (!def) {
+		return cssSyntaxMatch(value, type as CssSyntax);
+	}
+
+	const matched = isCSSSyntax(def) ? cssSyntaxMatch(value, def) : def.is(value);
+
+	if (!matched.matched) {
+		return {
+			...matched,
+			ref: matched.ref || def.ref,
+			expects: matched.expects || def.expects,
+		};
+	}
+	return matched;
+}

package/src/list.spec.ts

@@ -0,0 +1,133 @@
+import { checkList } from './list';
+
+test('Zero space', () => {
+	const type = { token: 'Zero', separator: 'space' } as const;
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(true);
+	expect(checkList(' 0 0', type).matched).toBe(true);
+	expect(checkList(' 0 0 ', type).matched).toBe(true);
+	expect(checkList('0 0 0 ', type).matched).toBe(true);
+	expect(checkList('0 0 0 0', type).matched).toBe(true);
+	expect(checkList('0 0 0    0', type).matched).toBe(true);
+	expect(checkList('1', type).matched).toBe(false);
+	expect(checkList(' 1 ', type).matched).toBe(false);
+	expect(checkList(' 1 0', type).matched).toBe(false);
+	expect(checkList(' 1 0 ', type).matched).toBe(false);
+	expect(checkList('0 1 0 ', type).matched).toBe(false);
+	expect(checkList('0 1 0 0', type).matched).toBe(false);
+	expect(checkList('0 1 0    0', type).matched).toBe(false);
+});
+
+test('Zero comma', () => {
+	const type = { token: 'Zero', separator: 'comma' } as const;
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(true);
+	expect(checkList(' 0 0', type).matched).toBe(false);
+	expect(checkList(' 0,0', type).matched).toBe(true);
+	expect(checkList(' 0,,0 ', type).matched).toBe(false);
+	expect(checkList('0 0 0 ', type).matched).toBe(false);
+	expect(checkList(' 0,0,0,0 ', type).matched).toBe(true);
+	expect(checkList('0, 0, 0 , 0', type).matched).toBe(true);
+	expect(checkList('0,0,0,0,', type).matched).toBe(false);
+	expect(checkList(',0,0,0,0', type).matched).toBe(false);
+});
+
+test('Zero comma (disallowToSurroundBySpaces)', () => {
+	const type = { token: 'Zero', separator: 'comma', disallowToSurroundBySpaces: true } as const;
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(false);
+	expect(checkList(' 0 0', type).matched).toBe(false);
+	expect(checkList(' 0,0', type).matched).toBe(false);
+	expect(checkList(' 0,,0 ', type).matched).toBe(false);
+	expect(checkList('0 0 0 ', type).matched).toBe(false);
+	expect(checkList(' 0,0,0,0 ', type).matched).toBe(false);
+	expect(checkList('0, 0, 0 , 0', type).matched).toBe(false);
+	expect(checkList('0,0,0,0', type).matched).toBe(true);
+	expect(checkList('0,0,0,0,', type).matched).toBe(false);
+	expect(checkList(',0,0,0,0', type).matched).toBe(false);
+});
+
+test('Location of the token', () => {
+	const type = { token: 'Accept', separator: 'comma' } as const;
+	expect(checkList('x/y;a=b', type)).toStrictEqual({
+		candicate: 'x/y',
+		column: 4,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 1,
+		matched: false,
+		offset: 3,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		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',
+		column: 8,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 1,
+		matched: false,
+		offset: 7,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		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',
+		column: 4,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 3,
+		matched: false,
+		offset: 9,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
+	});
+});
+
+test('Expected comma', () => {
+	const type = { token: 'Accept', separator: 'comma' } as const;
+	expect(checkList('x/y,', type)).toStrictEqual({
+		column: 4,
+		expects: undefined,
+		length: 1,
+		line: 1,
+		matched: false,
+		offset: 3,
+		raw: ',',
+		reason: 'extra-token',
+		ref: null,
+	});
+	expect(checkList('x/y,,x/y', type)).toStrictEqual({
+		column: 5,
+		expects: undefined,
+		length: 1,
+		line: 1,
+		matched: false,
+		offset: 4,
+		raw: ',',
+		reason: 'unexpected-comma',
+		ref: null,
+	});
+});
+
+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',
+		expects: undefined,
+		length: 3,
+		line: 1,
+		matched: false,
+		offset: 8,
+		raw: 'a/z',
+		reason: 'missing-comma',
+		ref: null,
+	});
+});

package/src/list.ts

@@ -0,0 +1,34 @@
+import type { Result } from './types';
+import type { List } from './types.schema';
+
+import { check } from './check';
+import { matched } from './match-result';
+import { Token, TokenCollection } from './token';
+
+export function checkList(value: string, type: List, ref?: string, cache = true): Result {
+	const tokens = new TokenCollection(value, type);
+
+	const matches = tokens.check({ ref });
+
+	if (!matches.matched) {
+		return matches;
+	}
+
+	const identTokens = tokens.getIdentTokens();
+
+	for (const token of identTokens) {
+		const res = check(token.value, type.token, ref, cache);
+		if (!res.matched) {
+			const { offset, line, column } = Token.shiftLocation(token, res.offset);
+			return {
+				...res,
+				partName: res.partName || 'the content of the list',
+				offset,
+				line,
+				column,
+			};
+		}
+	}
+
+	return matched();
+}

package/src/match-result.ts

@@ -0,0 +1,49 @@
+import type {
+	FormattedPrimitiveTypeCheck,
+	MatchedResult,
+	UnmatchedResult,
+	UnmatchedResultOptions,
+	UnmatchedResultReason,
+} from './types';
+
+export function matches(
+	checker: FormattedPrimitiveTypeCheck,
+	options?: UnmatchedResultOptions & {
+		ref?: string;
+		reason?: UnmatchedResultReason;
+	},
+) {
+	return (value: string) => {
+		const valid = checker(value);
+		if (!valid && !value) {
+			return unmatched(value, 'empty-token', options);
+		}
+		return valid ? matched() : unmatched(value, options?.reason, options);
+	};
+}
+
+export function matched(): MatchedResult {
+	return {
+		matched: true,
+	};
+}
+
+export function unmatched(
+	value: string,
+	reason?: UnmatchedResultReason,
+	options?: UnmatchedResultOptions & {
+		ref?: string;
+	},
+): UnmatchedResult {
+	return {
+		...options,
+		matched: false,
+		ref: options?.ref || null,
+		raw: value,
+		offset: 0,
+		length: value.length,
+		line: 1,
+		column: 1,
+		reason: reason ?? 'syntax-error',
+	};
+}

package/src/number.ts

@@ -0,0 +1,46 @@
+import type { Result } from './types';
+import type { Number } from './types.schema';
+
+import { matched, unmatched } from './match-result';
+import { isFloat, isInt } from './primitive';
+
+export function checkNumber(value: string, type: Number, ref?: string): Result {
+	if (!value) {
+		return unmatched(value, 'empty-token');
+	}
+	const syntaxMatched = type.type === 'float' ? isFloat(value) : isInt(value);
+	if (syntaxMatched) {
+		const n = parseFloat(value);
+		if (!isFinite(n)) {
+			return unmatched(value, 'unexpected-token');
+		}
+
+		const clampable = type.clampable;
+		const isInt = type.type === 'integer';
+
+		if (type.gt != null && type.gt < n) {
+			return unmatched(value, 'out-of-range', {
+				candicate: clampable && isInt ? `${type.gt + 1}` : undefined,
+			});
+		}
+
+		if (type.gte != null && type.gte <= n) {
+			return unmatched(value, 'out-of-range', {
+				candicate: clampable ? `${type.gte}` : undefined,
+			});
+		}
+
+		if (type.lt != null && n < type.lt) {
+			return unmatched(value, 'out-of-range', {
+				candicate: clampable && isInt ? `${type.lt - 1}` : undefined,
+			});
+		}
+
+		if (type.lte != null && n <= type.lte) {
+			return unmatched(value, 'out-of-range', {
+				candicate: clampable ? `${type.lte}` : undefined,
+			});
+		}
+	}
+	return syntaxMatched ? matched() : unmatched(value, 'unexpected-token');
+}

package/src/primitive/index.spec.ts

@@ -0,0 +1,65 @@
+import { isInt, isUint, isFloat, isNonZeroUint, isQuantity } from '.';
+
+test('int', () => {
+	expect(isInt('0')).toBe(true);
+	expect(isInt('1')).toBe(true);
+	expect(isInt('-0')).toBe(true);
+	expect(isInt('-1')).toBe(true);
+	expect(isInt('10')).toBe(true);
+	expect(isInt('100')).toBe(true);
+	expect(isInt('1.00')).toBe(false);
+	expect(isInt('.001')).toBe(false);
+	expect(isInt(' 1 ')).toBe(false);
+	expect(isInt('- 1')).toBe(false);
+});
+
+test('uint', () => {
+	expect(isUint('0')).toBe(true);
+	expect(isUint('1')).toBe(true);
+	expect(isUint('10')).toBe(true);
+	expect(isUint('100')).toBe(true);
+	expect(isUint('-0')).toBe(false);
+	expect(isUint('-1')).toBe(false);
+	expect(isUint('1.00')).toBe(false);
+	expect(isUint('.001')).toBe(false);
+	expect(isUint(' 1 ')).toBe(false);
+	expect(isUint('- 1')).toBe(false);
+});
+
+test('float', () => {
+	expect(isFloat('0')).toBe(true);
+	expect(isFloat('1')).toBe(true);
+	expect(isFloat('10')).toBe(true);
+	expect(isFloat('100')).toBe(true);
+	expect(isFloat('-0')).toBe(true);
+	expect(isFloat('-1')).toBe(true);
+	expect(isFloat('1.00')).toBe(true);
+	expect(isFloat('.001')).toBe(true);
+	expect(isFloat(' 1 ')).toBe(false);
+	expect(isFloat('- 1')).toBe(false);
+});
+
+test('nonZeroUint', () => {
+	expect(isNonZeroUint('0')).toBe(false);
+	expect(isNonZeroUint('1')).toBe(true);
+	expect(isNonZeroUint('10')).toBe(true);
+	expect(isNonZeroUint('100')).toBe(true);
+	expect(isNonZeroUint('-0')).toBe(false);
+	expect(isNonZeroUint('-1')).toBe(false);
+	expect(isNonZeroUint('1.00')).toBe(false);
+	expect(isNonZeroUint('.001')).toBe(false);
+	expect(isNonZeroUint(' 1 ')).toBe(false);
+	expect(isNonZeroUint('- 1')).toBe(false);
+});
+
+test('quantity', () => {
+	expect(isQuantity('0px', ['px', 'em'])).toBe(true);
+	expect(isQuantity('.5px', ['px', 'em'])).toBe(true);
+	expect(isQuantity('1.5em', ['px', 'em'])).toBe(true);
+	expect(isQuantity('1.5cm', ['px', 'em'])).toBe(false);
+	expect(isQuantity('1.5px', ['px', 'em'], 'int')).toBe(false);
+	expect(isQuantity('-5px', ['px', 'em'], 'int')).toBe(true);
+	expect(isQuantity('-5px', ['px', 'em'], 'uint')).toBe(false);
+	expect(isQuantity('1.12e+21px', ['px', 'em'], 'float')).toBe(true);
+	expect(isQuantity('1.12e+21px', ['px', 'em'], 'int')).toBe(false);
+});

package/src/primitive/index.ts

@@ -0,0 +1,7 @@
+export { isInt } from './is-int';
+export { isUint } from './is-uint';
+export { isFloat } from './is-float';
+export { isNonZeroUint } from './is-non-zero-uint';
+export { isQuantity } from './is-quantity';
+export { splitUnit } from './split-unit';
+export { range } from './range';

package/src/primitive/is-float.ts

@@ -0,0 +1,8 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#floating-point-numbers
+ *
+ * @param value
+ */
+export function isFloat(value: string) {
+	return value === value.trim() && Number.isFinite(parseFloat(value));
+}

package/src/primitive/is-int.ts

@@ -0,0 +1,8 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#signed-integers
+ *
+ * @param value
+ */
+export function isInt(value: string) {
+	return /^-?[0-9]+$/.test(value);
+}

package/src/primitive/is-non-zero-uint.ts

@@ -0,0 +1,8 @@
+/**
+ * Non-negative integer greater than zero
+ *
+ * @param value
+ */
+export function isNonZeroUint(value: string) {
+	return /^[0-9]+$/.test(value) && !/^0+$/.test(value);
+}

package/src/primitive/is-quantity.ts

@@ -0,0 +1,38 @@
+import { isFloat } from './is-float';
+import { isInt } from './is-int';
+import { isUint } from './is-uint';
+import { splitUnit } from './split-unit';
+
+/**
+ *
+ * @param value
+ * @param units
+ * @param numberType
+ */
+export function isQuantity(value: string, units: string[], numberType: 'int' | 'uint' | 'float' = 'float') {
+	const { num, unit } = splitUnit(value);
+	if (!units.includes(unit.toLowerCase())) {
+		return false;
+	}
+	switch (numberType) {
+		case 'int': {
+			if (!isInt(num)) {
+				return false;
+			}
+			break;
+		}
+		case 'uint': {
+			if (!isUint(num)) {
+				return false;
+			}
+			break;
+		}
+		case 'float': {
+			if (!isFloat(num)) {
+				return false;
+			}
+			break;
+		}
+	}
+	return true;
+}

package/src/primitive/is-uint.ts

@@ -0,0 +1,15 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#non-negative-integers
+ *
+ * @param value
+ */
+export function isUint(value: string, opions?: { gt?: number }) {
+	const matched = /^[0-9]+$/.test(value);
+	if (matched && opions) {
+		const n = parseInt(value, 10);
+		if (opions.gt != null) {
+			return isFinite(n) && opions.gt < n;
+		}
+	}
+	return matched;
+}

package/src/primitive/range.ts

@@ -0,0 +1,14 @@
+/**
+ * It is in the range between `from` and `to`.
+ *
+ * @param value
+ * @param from
+ * @param to
+ */
+export function range(value: string, from: number, to: number) {
+	const num = parseFloat(value);
+	if (isNaN(num)) {
+		return false;
+	}
+	return from <= num && num <= to;
+}

package/src/primitive/split-unit.ts

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param value
+ * @returns
+ */
+export function splitUnit(value: string) {
+	value = value.trim().toLowerCase();
+	const matched = value.match(/(^-?\.[0-9]+|^-?[0-9]+(?:\.[0-9]+(?:e[+-][0-9]+)?)?)([a-z]+$)/i);
+	if (!matched) {
+		return {
+			num: value,
+			unit: '',
+		};
+	}
+	const [, num, unit] = matched;
+	return {
+		num,
+		unit,
+	};
+}

package/src/rfc/is-bcp-47.spec.ts

@@ -0,0 +1,23 @@
+import { isBCP47 } from './is-bcp-47';
+
+const is = isBCP47();
+
+test('en-us', () => {
+	expect(is('en-us')).toBe(true);
+});
+
+test('ja-JP', () => {
+	expect(is('ja-JP')).toBe(true);
+});
+
+test('Empty', () => {
+	expect(is('')).toBe(false);
+});
+
+test('Invalid', () => {
+	expect(is(':::')).toBe(false);
+});
+
+test('Surrounded by spaces', () => {
+	expect(is(' en ')).toBe(false);
+});

package/src/rfc/is-bcp-47.ts

@@ -0,0 +1,13 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+
+import { parse } from 'bcp-47';
+
+/**
+ * @see https://tools.ietf.org/rfc/bcp/bcp47.html
+ */
+export const isBCP47: FormattedPrimitiveTypeCreator = () => {
+	return value => {
+		const { language } = parse(value);
+		return !!language;
+	};
+};

package/src/token/index.ts

@@ -0,0 +1,2 @@
+export { Token } from './token';
+export { TokenCollection } from './token-collection';