@markuplint/types 3.0.0-dev.25 → 3.0.0-dev.290

package/src/enum.ts

@@ -1,25 +0,0 @@
-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-candidate.ts

@@ -1,24 +0,0 @@
-import leven from 'leven';
-
-type NullableString = string | null | undefined;
-
-export function getCandidate(value: NullableString, ...candidates: (NullableString | NullableString[])[]) {
-	if (!value) {
-		return;
-	}
-	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) {
-			candidate = word;
-		}
-		maxRatio = Math.max(ratio, maxRatio);
-	});
-	if (value === candidate) {
-		return;
-	}
-	return candidate;
-}

package/src/index.ts

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

package/src/keyword-type.ts

@@ -1,64 +0,0 @@
-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';
-import { matched } from './match-result';
-
-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);
-		if (log.enabled) {
-			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) {
-		log('The "%s" type is not defined in custom type identifier markuplint specified', type);
-		try {
-			return cssSyntaxMatch(value, type as CssSyntax);
-		} catch (e) {
-			if (e instanceof Error && e.message === 'MARKUPLINT_TYPE_NO_EXIST') {
-				log("Allow all of any value because the type doesn't exist");
-				return matched();
-			}
-			throw e;
-		}
-	}
-
-	const matches = isCSSSyntax(def) ? cssSyntaxMatch(value, def) : def.is(value);
-
-	if (!matches.matched) {
-		return {
-			...matches,
-			ref: matches.ref || def.ref,
-			expects: matches.expects || def.expects,
-		};
-	}
-	return matches;
-}

package/src/list.spec.ts

@@ -1,133 +0,0 @@
-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({
-		candidate: '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({
-		candidate: '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({
-		candidate: '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,
-		candidate: ',a/z',
-		expects: undefined,
-		length: 3,
-		line: 1,
-		matched: false,
-		offset: 8,
-		raw: 'a/z',
-		reason: 'missing-comma',
-		ref: null,
-	});
-});

package/src/list.ts

@@ -1,34 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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 && n <= type.gt) {
-			return unmatched(value, 'out-of-range', {
-				candidate: clampable && isInt ? `${type.gt + 1}` : undefined,
-			});
-		}
-
-		if (type.gte != null && n < type.gte) {
-			return unmatched(value, 'out-of-range', {
-				candidate: clampable ? `${type.gte}` : undefined,
-			});
-		}
-
-		if (type.lt != null && type.lt <= n) {
-			return unmatched(value, 'out-of-range', {
-				candidate: clampable && isInt ? `${type.lt - 1}` : undefined,
-			});
-		}
-
-		if (type.lte != null && type.lte < n) {
-			return unmatched(value, 'out-of-range', {
-				candidate: clampable ? `${type.lte}` : undefined,
-			});
-		}
-	}
-	return syntaxMatched ? matched() : unmatched(value, 'unexpected-token');
-}

package/src/primitive/index.spec.ts

@@ -1,65 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,8 +0,0 @@
-/**
- * @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

@@ -1,8 +0,0 @@
-/**
- * @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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-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

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

package/src/primitive/range.ts

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- *
- * @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

@@ -1,23 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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