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

package/README.md

@@ -61,7 +61,7 @@ check('2020-02-30', 'DateTime');
 | `BrowsingContextNameOrKeyword` | `a[target]` and more                | [WHATWG](https://html.spec.whatwg.org/multipage/browsers.html#valid-browsing-context-name-or-keyword)              | ✅        |
 | `HTTPSchemaURL`                | `a[ping]` (as list) and more        | [WHATWG](https://html.spec.whatwg.org/multipage/links.html#ping)                                                   | ✅        |
 | `MIMEType`                     | `embed[type]` and more              | [WHATWG](https://mimesniff.spec.whatwg.org/#valid-mime-type)                                                       | ✅        |
-| `ItemProp`                     | The `itemprop` attibute (as list)   | [WHATWG](https://html.spec.whatwg.org/multipage/microdata.html#names:-the-itemprop-attribute)                      | ✅        |
+| `ItemProp`                     | The `itemprop` attribute (as list)  | [WHATWG](https://html.spec.whatwg.org/multipage/microdata.html#names:-the-itemprop-attribute)                      | ✅        |
 | `Srcset`                       | `img[srcset]` and more              | [WHATWG](https://html.spec.whatwg.org/multipage/images.html#srcset-attributes)                                     | ✅        |
 | `SourceSizeList`               | `img[sizes]` and more               | [WHATWG](https://html.spec.whatwg.org/multipage/images.html#sizes-attributes)                                      | ✅        |
 | `IconSize`                     | `link[sizes]` (as list)             | [WHATWG](https://html.spec.whatwg.org/multipage/semantics.html#attr-link-sizes)                                    | ✅        |

package/lib/css-syntax.spec.js

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

package/lib/defs.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenizers = exports.types = void 0;
 const check_multi_types_1 = require("./check-multi-types");
-const get_candicate_1 = require("./get-candicate");
+const get_candidate_1 = require("./get-candidate");
 const match_result_1 = require("./match-result");
 const primitive_1 = require("./primitive");
 const is_bcp_47_1 = require("./rfc/is-bcp-47");
@@ -275,8 +275,8 @@ exports.types = {
                 return (0, match_result_1.matched)();
             }
             if (value[0] === '_') {
-                const candicate = (0, get_candicate_1.getCandicate)(value, keywords);
-                return (0, match_result_1.unmatched)(value, 'unexpected-token', { candicate });
+                const candidate = (0, get_candidate_1.getCandidate)(value, keywords);
+                return (0, match_result_1.unmatched)(value, 'unexpected-token', { candidate });
             }
             return (0, match_result_1.matches)((0, is_browser_context_name_1.isBrowserContextName)())(value);
         },
@@ -420,7 +420,7 @@ exports.types = {
             if (value === 'any') {
                 return (0, match_result_1.matched)();
             }
-            const tokens = new token_1.TokenCollection(value, { speificSeparator: 'x' });
+            const tokens = new token_1.TokenCollection(value, { specificSeparator: 'x' });
             const [width, sep, height, ...tail] = tokens;
             if (!width) {
                 return (0, match_result_1.unmatched)(value, 'unexpected-token');

package/lib/get-candidate.d.ts

@@ -0,0 +1,3 @@
+declare type NullableString = string | null | undefined;
+export declare function getCandidate(value: NullableString, ...candidates: (NullableString | NullableString[])[]): string | undefined;
+export {};

package/lib/{get-candicate.js → get-candidate.js}

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCandicate = void 0;
+exports.getCandidate = void 0;
 const tslib_1 = require("tslib");
 const leven_1 = tslib_1.__importDefault(require("leven"));
-function getCandicate(value, ...candicates) {
+function getCandidate(value, ...candidates) {
     if (!value) {
         return;
     }
-    const list = candicates.flat(2).filter((s) => !!s);
-    let candicate;
+    const list = candidates.flat(2).filter((s) => !!s);
+    let candidate;
     let maxRatio = 0;
     list.forEach(word => {
         const dist = (0, leven_1.default)(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;
 }
-exports.getCandicate = getCandicate;
+exports.getCandidate = getCandidate;

package/lib/list.spec.js

@@ -48,7 +48,7 @@ test('Zero comma (disallowToSurroundBySpaces)', () => {
 test('Location of the token', () => {
     const type = { token: 'Accept', separator: 'comma' };
     expect((0, list_1.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,
@@ -61,7 +61,7 @@ test('Location of the token', () => {
         ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
     });
     expect((0, list_1.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,
@@ -74,7 +74,7 @@ test('Location of the token', () => {
         ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
     });
     expect((0, list_1.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,
@@ -116,7 +116,7 @@ test('Missing comma', () => {
     const type = { token: 'Accept', separator: 'comma' };
     expect((0, list_1.checkList)('a/b,x/y a/z', type)).toStrictEqual({
         column: 9,
-        candicate: ',a/z',
+        candidate: ',a/z',
         expects: undefined,
         length: 3,
         line: 1,

package/lib/number.js

@@ -17,22 +17,22 @@ function checkNumber(value, type, ref) {
         const isInt = type.type === 'integer';
         if (type.gt != null && n <= type.gt) {
             return (0, match_result_1.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 (0, match_result_1.unmatched)(value, 'out-of-range', {
-                candicate: clampable ? `${type.gte}` : undefined,
+                candidate: clampable ? `${type.gte}` : undefined,
             });
         }
         if (type.lt != null && type.lt <= n) {
             return (0, match_result_1.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 (0, match_result_1.unmatched)(value, 'out-of-range', {
-                candicate: clampable ? `${type.lte}` : undefined,
+                candidate: clampable ? `${type.lte}` : undefined,
             });
         }
     }

package/lib/primitive/is-uint.d.ts

@@ -3,6 +3,6 @@
  *
  * @param value
  */
-export declare function isUint(value: string, opions?: {
+export declare function isUint(value: string, options?: {
     gt?: number;
 }): boolean;

package/lib/primitive/is-uint.js

@@ -6,12 +6,12 @@ exports.isUint = void 0;
  *
  * @param value
  */
-function isUint(value, opions) {
+function isUint(value, options) {
     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/lib/token/token-collection.d.ts

@@ -2,61 +2,61 @@ import type { UnmatchedResult } from '..';
 import type { Expect, Result, List } from '../types';
 import { Token } from './token';
 declare type TokenCollectionOptions = Partial<Omit<List, 'token'> & {
-    speificSeparator: string | string[];
+    specificSeparator: string | string[];
 }>;
 export declare type TokenEachCheck = (head: Token | null, tail: TokenCollection) => Result | void;
 export declare class TokenCollection extends Array<Token> {
-    private static _new;
-    static fromPatterns(value: Token | string, patterns: RegExp[], typeOptions?: Omit<TokenCollectionOptions, 'speificSeparator'> & {
+    static fromPatterns(value: Token | string, patterns: RegExp[], typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & {
         repeat?: boolean;
     }): TokenCollection;
     static get [Symbol.species](): ArrayConstructor;
-    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);
     get value(): string;
+    check(options?: {
+        expects?: Expect[];
+        ref?: string;
+        cache?: boolean;
+    }): import("..").MatchedResult | UnmatchedResult;
+    chunk(split: number): TokenCollection[];
+    compareTokens(callback: (prev: Token, current: Token) => Token | null | void): Token | null | undefined;
+    divide(position: number): readonly [TokenCollection, TokenCollection];
+    eachCheck(...callbacks: TokenEachCheck[]): Result;
     filter(callback: (value: Token, index: number, array: Token[]) => boolean): TokenCollection;
-    headAndTail(): {
-        head: Token | null;
-        tail: TokenCollection;
-    };
+    getConsecutiveToken(tokenType: number): Token | null;
+    getDuplicated(): Token | null;
     getIdentTokens(): TokenCollection;
-    compareTokens(callback: (prev: Token, current: Token) => Token | null | void): Token | null | undefined;
     /**
      *
      * @param value The token value or the token type or its list
      */
     has(value: string | RegExp | number | (string | RegExp | number)[]): boolean;
+    headAndTail(): {
+        head: Token | null;
+        tail: TokenCollection;
+    };
     /**
      *
      * @param value The token value or the token type or its list
      */
     search(value: string | RegExp | number | (string | RegExp | number)[]): Token | null;
-    check(options?: {
-        expects?: Expect[];
-        ref?: string;
-        cache?: boolean;
-    }): import("..").MatchedResult | UnmatchedResult;
-    getConsecutiveToken(tokenType: number): Token | null;
     takeTurns(tokenNumbers: ReadonlyArray<number>, lastTokenNumber?: number): {
         unexpectedLastToken: boolean;
         expectedTokenNumber: number;
         token: Token;
     } | null;
-    eachCheck(...callbacks: TokenEachCheck[]): Result;
-    getDuplicated(): Token | null;
-    divide(position: number): readonly [TokenCollection, TokenCollection];
-    chunk(split: number): TokenCollection[];
     toJSON(): {
         type: number;
         value: string;
         offset: number;
     }[];
+    private static _new;
 }
 export {};

package/lib/token/token-collection.js

@@ -24,12 +24,12 @@ class TokenCollection extends Array {
         if (this.separator === 'comma') {
             separators.push(',');
         }
-        if (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.speificSeparator) {
-            if (Array.isArray(typeOptions.speificSeparator)) {
-                separators.push(...typeOptions.speificSeparator);
+        if (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.specificSeparator) {
+            if (Array.isArray(typeOptions.specificSeparator)) {
+                separators.push(...typeOptions.specificSeparator);
             }
             else {
-                separators.push(typeOptions.speificSeparator);
+                separators.push(typeOptions.specificSeparator);
             }
         }
         const chars = value.split('');
@@ -60,11 +60,6 @@ class TokenCollection extends Array {
             offset += v.length;
         });
     }
-    static _new(tokens, old) {
-        const newCollection = new TokenCollection('', old);
-        newCollection.push(...tokens);
-        return newCollection;
-    }
     static fromPatterns(value, patterns, typeOptions) {
         const origin = typeof value === 'string' ? value : value.origin;
         let strings = typeof value === 'string' ? value : value.value;
@@ -77,14 +72,14 @@ class TokenCollection extends Array {
             cumulativeOffset += tokenValue.length;
             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;
                 if (!res) {
-                    isBreaked = true;
+                    isBroken = true;
                     value = '';
                 }
                 else {
@@ -99,7 +94,7 @@ class TokenCollection extends Array {
                 // @ts-ignore
                 token._ = pattern;
             }
-            if (isBreaked) {
+            if (isBroken) {
                 addToken(strings);
             }
         } while ((typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.repeat) && strings);
@@ -115,56 +110,6 @@ class TokenCollection extends Array {
         const value = this.map(t => t.value).join('');
         return value;
     }
-    filter(callback) {
-        return TokenCollection._new(super.filter(callback), this);
-    }
-    headAndTail() {
-        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_1.Token.Ident);
-    }
-    compareTokens(callback) {
-        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) {
-        return this.some(t => t.match(value));
-    }
-    /**
-     *
-     * @param value The token value or the token type or its list
-     */
-    search(value) {
-        for (const token of this) {
-            if (token.includes(value)) {
-                return token;
-            }
-        }
-        return null;
-    }
     check(options = {}) {
         var _c;
         const { expects, ref } = options;
@@ -217,7 +162,7 @@ class TokenCollection extends Array {
                     reason: 'missing-comma',
                     ref,
                     expects,
-                    candicate: `,${takeTurnsError.token.value}`,
+                    candidate: `,${takeTurnsError.token.value}`,
                 });
             }
         }
@@ -242,36 +187,39 @@ class TokenCollection extends Array {
         }
         return (0, match_result_1.matched)();
     }
-    getConsecutiveToken(tokenType) {
-        const resultToken = this.compareTokens((prev, current) => {
-            if (prev.type === tokenType && current.type === tokenType) {
-                return current;
-            }
-        });
-        return resultToken || null;
-    }
-    takeTurns(tokenNumbers, lastTokenNumber) {
+    chunk(split) {
+        const chunks = [];
         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,
-                };
+        while (tokens.length) {
+            const chunkTokens = tokens.splice(0, split);
+            const chunk = TokenCollection._new(chunkTokens, this);
+            chunks.push(chunk);
+        }
+        return chunks;
+    }
+    compareTokens(callback) {
+        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) {
+        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];
+    }
     eachCheck(...callbacks) {
         let headAndTail = this.headAndTail();
         let head = headAndTail.head;
@@ -338,6 +286,17 @@ class TokenCollection extends Array {
         }
         return (0, match_result_1.matched)();
     }
+    filter(callback) {
+        return TokenCollection._new(super.filter(callback), this);
+    }
+    getConsecutiveToken(tokenType) {
+        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();
@@ -359,25 +318,66 @@ class TokenCollection extends Array {
         }
         return null;
     }
-    divide(position) {
-        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];
+    getIdentTokens() {
+        return this.filter(token => token.type === token_1.Token.Ident);
     }
-    chunk(split) {
-        const chunks = [];
+    /**
+     *
+     * @param value The token value or the token type or its list
+     */
+    has(value) {
+        return this.some(t => t.match(value));
+    }
+    headAndTail() {
+        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) {
+        for (const token of this) {
+            if (token.includes(value)) {
+                return token;
+            }
+        }
+        return null;
+    }
+    takeTurns(tokenNumbers, lastTokenNumber) {
         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());
     }
+    static _new(tokens, old) {
+        const newCollection = new TokenCollection('', old);
+        newCollection.push(...tokens);
+        return newCollection;
+    }
 }
 exports.TokenCollection = TokenCollection;

package/lib/token/token-collection.spec.js

@@ -41,7 +41,7 @@ test('parse', () => {
         },
     ]);
 });
-test('parse camma separator', () => {
+test('parse comma separator', () => {
     expect(new token_collection_1.TokenCollection('a,, ,b,cde', { separator: 'comma' }).toJSON()).toStrictEqual([
         {
             offset: 0,
@@ -85,7 +85,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 token_collection_1.TokenCollection('a ,cde , f').toJSON()).toStrictEqual([
         {
             offset: 0,

package/lib/token/token.d.ts

@@ -1,14 +1,12 @@
 import type { UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from '../types';
 export declare class Token {
     #private;
-    static getType(value: string, separators?: string[]): 1 | 13 | 18;
-    static getLine(value: string, offset: number): number;
-    static getCol(value: string, offset: number): number;
-    static shiftLocation(token: Token, offset: number): {
-        offset: number;
-        line: number;
-        column: number;
-    };
+    /**
+     * @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
@@ -20,36 +18,38 @@ export declare class Token {
      * @see https://infra.spec.whatwg.org/#ascii-whitespace
      */
     static readonly whitespace: ReadonlyArray<string>;
-    /**
-     * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
-     */
-    static readonly Ident = 1;
-    static readonly WhiteSpace = 13;
-    static readonly Comma = 18;
+    static getCol(value: string, offset: number): number;
+    static getLine(value: string, offset: number): number;
+    static getType(value: string, separators?: string[]): 1 | 13 | 18;
+    static shiftLocation(token: Token, offset: number): {
+        offset: number;
+        line: number;
+        column: number;
+    };
+    readonly offset: number;
     readonly type: number;
     readonly value: string;
-    readonly offset: number;
     constructor(value: string, offset: number, originalValue: string, separators?: string[]);
     get length(): number;
     get origin(): string;
-    unmatched(options?: UnmatchedResultOptions & {
-        ref?: string;
-        reason?: UnmatchedResultReason;
-    }): UnmatchedResult;
     /**
      *
      * @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;
     /**
      *
      * @param value The token value or the token type or its list
      */
-    includes(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
-    toNumber(): number;
+    match(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
     toJSON(): {
         type: number;
         value: string;
         offset: number;
     };
+    toNumber(): number;
+    unmatched(options?: UnmatchedResultOptions & {
+        ref?: string;
+        reason?: UnmatchedResultReason;
+    }): UnmatchedResult;
 }