@markuplint/types 1.0.0-dev.20211213.0

package/lib/primitive/split-unit.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param value
+ * @returns
+ */
+export declare function splitUnit(value: string): {
+    num: string;
+    unit: string;
+};

package/lib/primitive/split-unit.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUnit = void 0;
+/**
+ *
+ * @param value
+ * @returns
+ */
+function splitUnit(value) {
+    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,
+    };
+}
+exports.splitUnit = splitUnit;

package/lib/rfc/is-bcp-47.d.ts

@@ -0,0 +1,5 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+/**
+ * @see https://tools.ietf.org/rfc/bcp/bcp47.html
+ */
+export declare const isBCP47: FormattedPrimitiveTypeCreator;

package/lib/rfc/is-bcp-47.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBCP47 = void 0;
+const bcp_47_1 = require("bcp-47");
+/**
+ * @see https://tools.ietf.org/rfc/bcp/bcp47.html
+ */
+const isBCP47 = () => {
+    return value => {
+        const { language } = (0, bcp_47_1.parse)(value);
+        return !!language;
+    };
+};
+exports.isBCP47 = isBCP47;

package/lib/rfc/is-bcp-47.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rfc/is-bcp-47.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_bcp_47_1 = require("./is-bcp-47");
+const is = (0, is_bcp_47_1.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/lib/token/index.d.ts

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

package/lib/token/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenCollection = exports.Token = void 0;
+var token_1 = require("./token");
+Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return token_1.Token; } });
+var token_collection_1 = require("./token-collection");
+Object.defineProperty(exports, "TokenCollection", { enumerable: true, get: function () { return token_collection_1.TokenCollection; } });

package/lib/token/token-collection.d.ts

@@ -0,0 +1,62 @@
+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[];
+}>;
+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'> & {
+        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 number: List['number'];
+    readonly separator: NonNullable<List['separator']>;
+    constructor(value?: string, typeOptions?: TokenCollectionOptions);
+    constructor(value?: number);
+    get value(): string;
+    filter(callback: (value: Token, index: number, array: Token[]) => boolean): TokenCollection;
+    headAndTail(): {
+        head: Token | null;
+        tail: TokenCollection;
+    };
+    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;
+    /**
+     *
+     * @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;
+    }): UnmatchedResult | import("..").MatchedResult;
+    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;
+    }[];
+}
+export {};

package/lib/token/token-collection.js

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenCollection = void 0;
+const match_result_1 = require("../match-result");
+const token_1 = require("./token");
+class TokenCollection extends Array {
+    constructor(value, typeOptions) {
+        super();
+        this.disallowToSurroundBySpaces = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.disallowToSurroundBySpaces) || false;
+        this.allowEmpty = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.allowEmpty) || true;
+        this.ordered = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.ordered) || false;
+        this.unique = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.unique) || false;
+        this.caseInsensitive = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.caseInsensitive) || true;
+        this.number = typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.number;
+        this.separator = (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.separator) || 'space';
+        if (typeof value === 'number') {
+            this.length = value;
+            return;
+        }
+        if (!value) {
+            return;
+        }
+        const separators = [];
+        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);
+            }
+            else {
+                separators.push(typeOptions.speificSeparator);
+            }
+        }
+        const chars = value.split('');
+        const values = [];
+        let char;
+        while ((char = chars.shift())) {
+            const last = values.pop();
+            if (!last) {
+                values.push(char);
+                continue;
+            }
+            const lastChar = last[0];
+            if (!separators.includes(char) &&
+                !separators.includes(last[0]) &&
+                ((token_1.Token.whitespace.includes(lastChar) && token_1.Token.whitespace.includes(char)) ||
+                    (!token_1.Token.whitespace.includes(lastChar) && !token_1.Token.whitespace.includes(char)))) {
+                values.push(last + char);
+            }
+            else {
+                values.push(last);
+                values.push(char);
+            }
+        }
+        let offset = 0;
+        values.forEach(v => {
+            const token = new token_1.Token(v, offset, value, separators);
+            this.push(token);
+            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;
+        let cumulativeOffset = typeof value === 'string' ? 0 : value.offset;
+        const tokens = [];
+        function addToken(tokenValue) {
+            const token = new token_1.Token(tokenValue, cumulativeOffset, origin);
+            tokens.push(token);
+            strings = strings.slice(tokenValue.length);
+            cumulativeOffset += tokenValue.length;
+            return token;
+        }
+        let isBreaked = false;
+        do {
+            isBreaked = false;
+            for (const pattern of patterns) {
+                const res = pattern.exec(strings);
+                let value;
+                if (!res) {
+                    isBreaked = true;
+                    value = '';
+                }
+                else {
+                    if (res.index !== 0) {
+                        value = strings.slice(res.index + res[0].length);
+                    }
+                    else {
+                        value = res[0] || '';
+                    }
+                }
+                const token = addToken(value);
+                // @ts-ignore
+                token._ = pattern;
+            }
+            if (isBreaked) {
+                addToken(strings);
+            }
+        } while ((typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.repeat) && strings);
+        if (strings) {
+            addToken(strings);
+        }
+        return TokenCollection._new(tokens, new TokenCollection('', typeOptions));
+    }
+    static get [Symbol.species]() {
+        return Array;
+    }
+    get value() {
+        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;
+        if (this.disallowToSurroundBySpaces) {
+            for (const token of this) {
+                if (token.type === 13) {
+                    return token.unmatched({
+                        reason: 'unexpected-space',
+                        ref,
+                        expects,
+                    });
+                }
+            }
+        }
+        if (this.separator === 'comma') {
+            const tokensWithoutWP = this.filter(token => token.type !== token_1.Token.WhiteSpace);
+            const consecutiveComma = tokensWithoutWP.getConsecutiveToken(token_1.Token.Comma);
+            if (consecutiveComma) {
+                return consecutiveComma.unmatched({
+                    reason: 'unexpected-comma',
+                    ref,
+                    expects,
+                });
+            }
+            if (tokensWithoutWP[0] && tokensWithoutWP[0].type === token_1.Token.Comma) {
+                return tokensWithoutWP[0].unmatched({
+                    reason: 'unexpected-comma',
+                    ref,
+                    expects,
+                });
+            }
+            const takeTurnsError = tokensWithoutWP.takeTurns([token_1.Token.Ident, token_1.Token.Comma], token_1.Token.Ident);
+            if (takeTurnsError) {
+                if (takeTurnsError.unexpectedLastToken) {
+                    return takeTurnsError.token.unmatched({
+                        reason: 'extra-token',
+                        ref,
+                        expects,
+                    });
+                }
+                else if (takeTurnsError.token.type === takeTurnsError.expectedTokenNumber) {
+                    // Consecutive cammas
+                    return takeTurnsError.token.unmatched({
+                        reason: 'unexpected-comma',
+                        ref,
+                        expects,
+                    });
+                }
+                return takeTurnsError.token.unmatched({
+                    reason: 'missing-comma',
+                    ref,
+                    expects,
+                    candicate: `,${takeTurnsError.token.value}`,
+                });
+            }
+        }
+        const identTokens = this.getIdentTokens();
+        const allowEmpty = (_c = this.allowEmpty) !== null && _c !== void 0 ? _c : true;
+        if (!allowEmpty && identTokens.length === 0) {
+            return (0, match_result_1.unmatched)(this.value, 'empty-token', {
+                ref,
+                expects,
+            });
+        }
+        if (this.unique) {
+            const duplicated = identTokens.getDuplicated();
+            if (duplicated) {
+                return duplicated.unmatched({
+                    partName: 'the content of the list',
+                    reason: 'duplicated',
+                    ref,
+                    expects,
+                });
+            }
+        }
+        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) {
+        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,
+                };
+            }
+            if (lastTokenNumber != null && i === tokens.length - 1 && token.type !== lastTokenNumber) {
+                return {
+                    unexpectedLastToken: true,
+                    expectedTokenNumber,
+                    token,
+                };
+            }
+        }
+        return null;
+    }
+    eachCheck(...callbacks) {
+        let headAndTail = this.headAndTail();
+        let head = headAndTail.head;
+        let tail = headAndTail.tail;
+        let prev = null;
+        let cumulativeOffset = 0;
+        let passCount = 0;
+        let firstUnmatched = null;
+        let wait = 20;
+        for (const callback of callbacks) {
+            wait--;
+            const result = callback.call(this, head, tail);
+            if (result && !result.matched) {
+                passCount += result.passCount || 0;
+                if (prev && result.offset === 0 && result.length === 0) {
+                    const { offset, line, column } = token_1.Token.shiftLocation(prev, cumulativeOffset);
+                    firstUnmatched = firstUnmatched || {
+                        ...result,
+                        offset,
+                        line,
+                        column,
+                    };
+                }
+                if (!prev && this.value.length === 0) {
+                    firstUnmatched = firstUnmatched || {
+                        ...result,
+                        reason: 'empty-token',
+                        expects: undefined,
+                    };
+                }
+                switch (result.reason) {
+                    case 'extra-token': {
+                        passCount += 1;
+                        break;
+                    }
+                    default: {
+                        if (typeof result.reason !== 'string') {
+                            passCount += 2 * wait;
+                        }
+                    }
+                }
+                firstUnmatched = firstUnmatched || result;
+            }
+            else if (result && !firstUnmatched && result.matched) {
+                return result;
+            }
+            else {
+                if ((head === null || head === void 0 ? void 0 : head.value) && !head.match(/^\s*$/)) {
+                    passCount += 4 * wait;
+                }
+            }
+            cumulativeOffset = (head === null || head === void 0 ? void 0 : head.length) || 0;
+            headAndTail = tail.headAndTail();
+            prev = head;
+            head = headAndTail.head;
+            tail = headAndTail.tail;
+        }
+        if (firstUnmatched) {
+            const res = {
+                ...firstUnmatched,
+                passCount,
+            };
+            return res;
+        }
+        return (0, match_result_1.matched)();
+    }
+    getDuplicated() {
+        const aList = this.slice();
+        const bList = this.slice();
+        for (const aToken of aList) {
+            for (const bToken of bList) {
+                if (aToken.offset === bToken.offset) {
+                    continue;
+                }
+                let a = aToken.value;
+                let b = bToken.value;
+                if (this.caseInsensitive) {
+                    a = a.toLowerCase();
+                    b = b.toLowerCase();
+                }
+                if (a === b) {
+                    return bToken;
+                }
+            }
+        }
+        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];
+    }
+    chunk(split) {
+        const chunks = [];
+        const tokens = this.slice();
+        while (tokens.length) {
+            const chunkTokens = tokens.splice(0, split);
+            const chunk = TokenCollection._new(chunkTokens, this);
+            chunks.push(chunk);
+        }
+        return chunks;
+    }
+    toJSON() {
+        return this.map(t => t.toJSON());
+    }
+}
+exports.TokenCollection = TokenCollection;

package/lib/token/token-collection.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_collection_1 = require("./token-collection");
+const _1 = require(".");
+test('parse', () => {
+    expect(new token_collection_1.TokenCollection(' a  b   c    ').toJSON()).toStrictEqual([
+        {
+            offset: 0,
+            type: 13,
+            value: ' ',
+        },
+        {
+            offset: 1,
+            type: 1,
+            value: 'a',
+        },
+        {
+            offset: 2,
+            type: 13,
+            value: '  ',
+        },
+        {
+            offset: 4,
+            type: 1,
+            value: 'b',
+        },
+        {
+            offset: 5,
+            type: 13,
+            value: '   ',
+        },
+        {
+            offset: 8,
+            type: 1,
+            value: 'c',
+        },
+        {
+            offset: 9,
+            type: 13,
+            value: '    ',
+        },
+    ]);
+});
+test('parse camma separator', () => {
+    expect(new token_collection_1.TokenCollection('a,, ,b,cde', { separator: 'comma' }).toJSON()).toStrictEqual([
+        {
+            offset: 0,
+            type: 1,
+            value: 'a',
+        },
+        {
+            offset: 1,
+            type: 18,
+            value: ',',
+        },
+        {
+            offset: 2,
+            type: 18,
+            value: ',',
+        },
+        {
+            offset: 3,
+            type: 13,
+            value: ' ',
+        },
+        {
+            offset: 4,
+            type: 18,
+            value: ',',
+        },
+        {
+            offset: 5,
+            type: 1,
+            value: 'b',
+        },
+        {
+            offset: 6,
+            type: 18,
+            value: ',',
+        },
+        {
+            offset: 7,
+            type: 1,
+            value: 'cde',
+        },
+    ]);
+});
+test('A camma is an ident if the comma is not a separator', () => {
+    expect(new token_collection_1.TokenCollection('a ,cde , f').toJSON()).toStrictEqual([
+        {
+            offset: 0,
+            type: 1,
+            value: 'a',
+        },
+        {
+            offset: 1,
+            type: 13,
+            value: ' ',
+        },
+        {
+            offset: 2,
+            type: 1,
+            value: ',cde',
+        },
+        {
+            offset: 6,
+            type: 13,
+            value: ' ',
+        },
+        {
+            offset: 7,
+            type: 1,
+            value: ',',
+        },
+        {
+            offset: 8,
+            type: 13,
+            value: ' ',
+        },
+        {
+            offset: 9,
+            type: 1,
+            value: 'f',
+        },
+    ]);
+});
+test('getConsecutiveToken', () => {
+    var _a;
+    expect(new token_collection_1.TokenCollection('a,b,c', { separator: 'comma' }).getConsecutiveToken(_1.Token.Comma)).toBeFalsy();
+    expect(new token_collection_1.TokenCollection('a,,b', { separator: 'comma' }).getConsecutiveToken(_1.Token.Comma)).toBeTruthy();
+    expect((_a = new token_collection_1.TokenCollection('a,,b', { separator: 'comma' }).getConsecutiveToken(_1.Token.Comma)) === null || _a === void 0 ? void 0 : _a.offset).toBe(2);
+});
+test('fromPatterns', () => {
+    const patterns = [/\+|-/, /[0-9]{2}/, /:?/, /[0-9]{2}/];
+    expect(token_collection_1.TokenCollection.fromPatterns('+00:00', patterns).map(t => t.value)).toStrictEqual(['+', '00', ':', '00']);
+    expect(token_collection_1.TokenCollection.fromPatterns('+0000', patterns).map(t => t.value)).toStrictEqual(['+', '00', '', '00']);
+    expect(token_collection_1.TokenCollection.fromPatterns('+00/00', patterns).map(t => t.value)).toStrictEqual([
+        '+',
+        '00',
+        '',
+        '',
+        '/00',
+    ]);
+});