@tempots/std 0.9.2 → 0.9.5

package/dist/strings.js

@@ -1,685 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License")
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-/**
- * Utility functions to manipulate string values.
- */
-import { Ord } from './ord';
-import { range, any, all, fill } from './arrays';
-import { map as mapR } from './reg-exps';
-/**
- * Replaces all occurrances of `placeholder` in `subject` with the value `replacement`.
- * @param subject
- * @param placeholder
- * @param replacement
- */
-export function replace(subject, placeholder, replacement) {
-    return subject.split(placeholder).join(replacement);
-}
-/**
- * `after` searches for the first occurrance of `searchFor` and returns the text after that.
- * If `searchFor` is not found, an empty string is returned.
- */
-export function after(value, searchFor) {
-    const pos = value.indexOf(searchFor);
-    if (pos < 0)
-        return '';
-    else
-        return value.substring(pos + searchFor.length);
-}
-/**
- * `afterLast` searches for the last occurrance of `searchFor` and returns the text after that.
- * If `searchFor` is not found, an empty string is returned.
- */
-export function afterLast(value, searchFor) {
-    const pos = value.lastIndexOf(searchFor);
-    if (pos < 0)
-        return '';
-    else
-        return value.substring(pos + searchFor.length);
-}
-/**
- * `before` searches for the first occurrance of `searchFor` and returns the text before that.
- * If `searchFor` is not found, an empty string is returned.
- */
-export function before(value, searchFor) {
-    const pos = value.indexOf(searchFor);
-    if (pos < 0)
-        return '';
-    else
-        return value.substring(0, pos);
-}
-/**
- * `beforeLast` searches for the last occurrance of `searchFor` and returns the text before that.
- * If `searchFor` is not found, an empty string is returned.
- */
-export function beforeLast(value, searchFor) {
-    const pos = value.lastIndexOf(searchFor);
-    if (pos < 0)
-        return '';
-    else
-        return value.substring(0, pos);
-}
-/**
- * `capitalize` returns a string with the first character convert to upper case.
- */
-export function capitalize(s) {
-    return s.substring(0, 1).toUpperCase() + s.substring(1);
-}
-const upperMatch = (s) => s.toUpperCase();
-/**
- * Capitalize the first letter of every word in `value`. If `whiteSpaceOnly` is set to `true`
- * the process is limited to whitespace separated words.
- */
-export function capitalizeWords(value, whiteSpaceOnly = false) {
-    if (whiteSpaceOnly) {
-        return mapR(capitalize(value), UCWORDSWS, upperMatch);
-    }
-    else {
-        return mapR(capitalize(value), UCWORDS, upperMatch);
-    }
-}
-/**
- * Replaces occurrances of `\r\n`, `\n\r`, `\r` with `\n`
- */
-export function canonicalizeNewlines(value) {
-    return value.replace(CANONICALIZE_LINES, '\n');
-}
-/**
- * Compares two strings ignoring their case.
- */
-export function compareCaseInsensitive(a, b) {
-    if (a == null && b == null)
-        return 0;
-    if (a == null)
-        return -1;
-    else if (b == null)
-        return 1;
-    return compare(a.toLowerCase(), b.toLowerCase());
-}
-export function endsWith(s, end) {
-    return s.substring(0, s.length - end.length) === end;
-}
-export function endsWithCaseInsensitive(s, end) {
-    return (s.substring(0, s.length - end.length).toLowerCase() === end.toLowerCase());
-}
-export function startsWith(s, start) {
-    return s.substring(0, start.length) === start;
-}
-export function startsWithCaseInsensitive(s, start) {
-    return s.substring(0, start.length).toLowerCase() === start.toLowerCase();
-}
-/**
- * Compares a string `s` with many `values` and see if one of them matches its end ignoring their case.
- */
-export function endsWithAnyCaseInsensitive(s, values) {
-    return endsWithAny(s.toLowerCase(), values.map(v => v.toLowerCase()));
-}
-/**
- * Compares a string `s` with many `values` and see if one of them matches its beginning ignoring their case.
- */
-export function startsWithAnyCaseInsensitive(s, values) {
-    return startsWithAny(s.toLowerCase(), values.map(v => v.toLowerCase()));
-}
-/**
- * It cleans up all the whitespaces in the passed `value`. `collapse` does the following:
- * - remove trailing/leading whitespaces
- * - within the string, it collapses seqeunces of whitespaces into a single space character
- * For whitespaces in this description, it is intended to be anything that is matched by the regular expression `\s`.
- */
-export function collapse(value) {
-    return value.trim().replace(WSG, ' ');
-}
-/**
- * It compares to string and it returns a negative number if `a` is inferior to `b`, zero if they are the same,
- * or otherwise a positive non-sero number.
- */
-export function compare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-export const order = Ord.fromNumberComparison(compare);
-/**
- * `contains` returns `true` if `s` contains one or more occurrences of `test` regardless of the text case.
- */
-export function containsCaseInsensitive(s, test) {
-    return s.toLowerCase().includes(test.toLowerCase());
-}
-/**
- * `contains` returns `true` if `s` contains one or more occurrences of `test`.
- */
-export function contains(s, test) {
-    return s.includes(test);
-}
-/**
- * Return the number of occurances of `test` in `s`.
- */
-export function count(s, test) {
-    return s.split(test).length - 1;
-}
-/**
- * `contains` returns `true` if `s` contains any of the strings in `tests` regardless of the text case
- */
-export function containsAnyCaseInsensitive(s, tests) {
-    return any(tests, t => containsCaseInsensitive(s, t));
-}
-/**
- * `contains` returns `true` if `s` contains any of the strings in `tests`
- */
-export function containsAny(s, tests) {
-    return any(tests, t => contains(s, t));
-}
-/**
- * `contains` returns `true` if `s` contains all of the strings in `tests` regardless of the text case
- */
-export function containsAllCaseInsensitive(s, tests) {
-    return all(tests, t => containsCaseInsensitive(s, t));
-}
-/**
- * `contains` returns `true` if `s` contains all of the strings in `tests`
- */
-export function containsAll(s, tests) {
-    return all(tests, t => contains(s, t));
-}
-/**
- * `dasherize` replaces all the occurrances of `_` with `-`
- */
-export function dasherize(s) {
-    return s.replace('_', '-');
-}
-/**
- * Compares strings `a` and `b` and returns the position where they differ.
- * ```ts
- * diffIndex('abcdef', 'abc123') // returns 3
- * ```
- */
-export function diffIndex(a, b) {
-    const min = Math.min(a.length, b.length);
-    for (let i = 0; i < min; i++) {
-        if (a.substring(i, i + 1) !== b.substring(i, i + 1))
-            return i;
-    }
-    return min;
-}
-/**
- * `ellipsis` truncates `s` at len `maxlen` replaces the last characters with the content
- * of `symbol`.
- * ```ts
- * ellipsis('tempo is a nice library', 9) // returns 'tempo is …'
- * ```
- */
-export function ellipsis(s, maxlen = 20, symbol = '…') {
-    const sl = s.length;
-    const symboll = symbol.length;
-    if (sl > maxlen) {
-        if (maxlen < symboll) {
-            return symbol.substr(symboll - maxlen, maxlen);
-        }
-        else {
-            return s.substr(0, maxlen - symboll) + symbol;
-        }
-    }
-    else
-        return s;
-}
-/**
- * Same as `ellipsis` but puts the symbol in the middle of the string and not to the end.
- * ```ts
- * ellipsisMiddle('tempo is a nice library', 18) // returns 'tempo is … library'
- * ```
- */
-export function ellipsisMiddle(s, maxlen = 20, symbol = '…') {
-    const sl = s.length;
-    const symboll = symbol.length;
-    if (sl > maxlen) {
-        if (maxlen <= symboll) {
-            return ellipsis(s, maxlen, symbol);
-        }
-        const hll = Math.ceil((maxlen - symboll) / 2);
-        const hlr = Math.floor((maxlen - symboll) / 2);
-        return s.substr(0, hll) + symbol + s.substr(sl - hlr, hlr);
-    }
-    else
-        return s;
-}
-/**
- * Returns `true` if `s` ends with any of the values in `values`.
- */
-export function endsWithAny(s, values) {
-    return any(values, end => endsWith(s, end));
-}
-/**
- * `filter` applies `predicate` character by character to `s` and it returns a filtered
- * version of the string.
- */
-export function filter(s, predicate) {
-    return toArray(s).filter(predicate).join('');
-}
-/**
- * Same as `filter` but `predicate` operates on integer char codes instead of string characters.
- */
-export function filterCharcode(s, predicate) {
-    const codes = toCharcodes(s).filter(predicate);
-    return codes.map((i) => String.fromCharCode(i)).join('');
-}
-/**
- * `from` searches for the first occurrance of `searchFor` and returns the text from that point on.
- * If `searchFor` is not found, an empty string is returned.
- */
-export function from(value, searchFor) {
-    const pos = value.indexOf(searchFor);
-    if (pos < 0)
-        return '';
-    else
-        return value.substring(pos);
-}
-export function hashCode(value, seed = 0x811c9dc5) {
-    let hval = seed;
-    for (let i = 0, l = value.length; i < l; i++) {
-        hval ^= value.charCodeAt(i);
-        hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
-    }
-    return hval >>> 0;
-}
-/**
- * Returns `true` if `value` is not `null` and contains at least one character.
- */
-export function hasContent(value) {
-    return value != null && value.length > 0;
-}
-/**
- * Works the same as `underscore` but also replaces underscores with whitespaces.
- */
-export function humanize(s) {
-    return replace(underscore(s), '_', ' ');
-}
-/**
- * Checks if `s` contains only (and at least one) alphabetical characters.
- */
-export function isAlpha(s) {
-    return s.length > 0 && !IS_ALPHA.test(s);
-}
-/**
- * `isAlphaNum` returns `true` if the string only contains alpha-numeric characters.
- */
-export function isAlphaNum(value) {
-    return ALPHANUM.test(value);
-}
-export function isBreakingWhitespace(value) {
-    return !IS_BREAKINGWHITESPACE.test(value);
-}
-/**
- * Returns `true` if the value string is composed of only lower cased characters
- * or case neutral characters.
- */
-export function isLowerCase(value) {
-    return value.toLowerCase() === value;
-}
-/**
- * Returns `true` if the value string is composed of only upper cased characters
- * or case neutral characters.
- */
-export function isUpperCase(value) {
-    return value.toUpperCase() === value;
-}
-/**
- * `ifEmpty` returns `value` if it is neither `null` or empty, otherwise it returns `alt`
- */
-export function ifEmpty(value, alt) {
-    return value != null && value !== '' ? value : alt;
-}
-/**
- * `isDigitsOnly` returns `true` if the string only contains digits.
- */
-export function isDigitsOnly(value) {
-    return DIGITS.test(value);
-}
-/**
- * `isEmpty` returns true if either `value` is null or is an empty string.
- */
-export function isEmpty(value) {
-    return value == null || value === '';
-}
-/**
- * Convert first letter in `value` to lower case.
- */
-export function lowerCaseFirst(value) {
-    return value.substring(0, 1).toLowerCase() + value.substring(1);
-}
-/**
- * Returns a random substring from the `value` argument. The length of such value is by default `1`.
- */
-export function random(value, length = 1) {
-    return value.substring(Math.floor((value.length - length + 1) * Math.random()), length);
-}
-/**
- * Returns a random sampling of the specified length from the seed string.
- */
-export function randomSequence(alphabet, length) {
-    return range(length, () => random(alphabet)).join('');
-}
-/**
- * Like `randomSequence`, but automatically uses the base64 sequence as the seed string.
- */
-export function randomSequence64(length) {
-    return randomSequence(BASE64_ALPHABET, length);
-}
-/**
- * It maps a string character by character using `callback`.
- */
-export function map(callback, value) {
-    return toArray(value).map(callback);
-}
-/**
- * If present, it removes all the occurrences of `toremove` from `value`.
- */
-export function remove(value, toremove) {
-    return replace(value, toremove, '');
-}
-/**
- * If present, it removes the `toremove` text from the end of `value`.
- */
-export function removeAfter(value, toremove) {
-    return endsWith(value, toremove)
-        ? value.substring(0, value.length - toremove.length)
-        : value;
-}
-/**
- * Removes a slice from `index` to `index + length` from `value`.
- */
-export function removeAt(value, index, length) {
-    return value.substring(0, index) + value.substring(index + length);
-}
-/**
- * If present, it removes the `toremove` text from the beginning of `value`.
- */
-export function removeBefore(value, toremove) {
-    return startsWith(value, toremove) ? value.substring(toremove.length) : value;
-}
-/**
- * If present, it removes the first occurrence of `toremove` from `value`.
- */
-export function removeOne(value, toremove) {
-    const pos = value.indexOf(toremove);
-    if (pos < 0)
-        return value;
-    return value.substring(0, pos) + value.substring(pos + toremove.length);
-}
-/**
- * `repeat` builds a new string by repeating the argument `s`, n `times`.
- * ```ts
- * repeat('Xy', 3) // generates 'XyXyXy'
- * ```
- */
-export function repeat(s, times) {
-    return fill(times, s).join('');
-}
-/**
- * Returns a new string whose characters are in reverse order.
- */
-export function reverse(s) {
-    const arr = toArray(s);
-    arr.reverse();
-    return arr.join('');
-}
-/**
- * Converts a string in a quoted string.
- */
-export function quote(s) {
-    if (!s.includes('"'))
-        return '"' + s + '"';
-    else if (!s.includes("'"))
-        return "'" + s + "'";
-    else
-        return '"' + replace(s, '"', '\\"') + '"';
-}
-/**
- * It only splits on the first occurrance of separator.
- */
-export function splitOnce(s, separator) {
-    const pos = s.indexOf(separator);
-    if (pos < 0)
-        return [s];
-    return [s.substring(0, pos), s.substring(pos + separator.length)];
-}
-/**
- * Returns `true` if `s` starts with any of the values in `values`.
- */
-export function startsWithAny(s, values) {
-    return any(values, start => s.startsWith(start));
-}
-/**
- * `stripTags` removes any HTML/XML markup from the string leaving only the concatenation
- * of the existing text nodes.
- */
-export function stripTags(s) {
-    return s.replace(STRIPTAGS, '');
-}
-/**
- * Surrounds a string with the contents of `left` and `right`. If `right` is omitted,
- * `left` will be used on both sides
- */
-export function surround(s, left, right = left) {
-    return `${left}${s}${right}`;
-}
-/**
- * It transforms a string into an `Array` of characters.
- */
-export function toArray(s) {
-    return s.split('');
-}
-/**
- * It transforms a string into an `Array` of char codes in integer format.
- */
-export function toCharcodes(s) {
-    return range(s.length, i => s.charCodeAt(i));
-}
-/**
- * Returns an array of `string` whose elements are equally long (using `len`). If the string `s`
- * is not exactly divisible by `len` the last element of the array will be shorter.
- */
-export function toChunks(s, len) {
-    const chunks = [];
-    while (s.length > 0) {
-        chunks.push(s.substr(0, len));
-        s = s.substr(len, s.length - len);
-    }
-    return chunks;
-}
-/**
- * Returns an array of `string` split by line breaks.
- */
-export function toLines(s) {
-    return s.split(SPLIT_LINES);
-}
-/**
- * `trimChars` removes from the beginning and the end of the string any character that is present in `charlist`.
- */
-export function trimChars(value, charlist) {
-    return trimCharsRight(trimCharsLeft(value, charlist), charlist);
-}
-/**
- * `trimCharsLeft` removes from the beginning of the string any character that is present in `charlist`.
- */
-export function trimCharsLeft(value, charlist) {
-    let pos = 0;
-    for (let i = 0; i < value.length; i++) {
-        if (contains(charlist, value.charAt(i)))
-            pos++;
-        else
-            break;
-    }
-    return value.substring(pos);
-}
-/**
- * `trimCharsRight` removes from the end of the string any character that is present in `charlist`.
- */
-export function trimCharsRight(value, charlist) {
-    const len = value.length;
-    let pos = len;
-    let i;
-    for (let j = 0; j < len; j++) {
-        i = len - j - 1;
-        if (contains(charlist, value.charAt(i)))
-            pos = i;
-        else
-            break;
-    }
-    return value.substring(0, pos);
-}
-/**
- * `underscore` finds UpperCase characters and turns them into LowerCase and prepends them with a whtiespace.
- * Sequences of more than one UpperCase character are left untouched.
- */
-export function underscore(s) {
-    s = s.replace(/::/g, '/');
-    s = s.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2');
-    s = s.replace(/([a-z\d])([A-Z])/g, '$1_$2');
-    s = s.replace(/-/g, '_');
-    return s.toLowerCase();
-}
-/**
- * Convert first letter in `value` to upper case.
- */
-export function upperCaseFirst(value) {
-    return value.substring(0, 1).toUpperCase() + value.substring(1);
-}
-/**
- * `upTo` searches for the first occurrance of `searchFor` and returns the text up to that point.
- * If `searchFor` is not found, the entire string is returned.
- */
-export function upTo(value, searchFor) {
-    const pos = value.indexOf(searchFor);
-    if (pos < 0)
-        return value;
-    else
-        return value.substring(0, pos);
-}
-/**
- * `wrapColumns` splits a long string into lines that are at most `columns` long.
- * Words whose length exceeds `columns` are not split.
- */
-export function wrapColumns(s, columns = 78, indent = '', newline = '\n') {
-    return s
-        .split(SPLIT_LINES)
-        .map(part => wrapLine(part.replace(WSG, ' ').trim(), columns, indent, newline))
-        .join(newline);
-}
-export function isSpaceAt(s, pos) {
-    if (pos < 0 || pos >= s.length)
-        return false;
-    const char = s.charCodeAt(pos);
-    return (char === 9 ||
-        char === 10 ||
-        char === 11 ||
-        char === 12 ||
-        char === 13 ||
-        char === 32);
-}
-export function encodeBase64(s) {
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(s).toString('base64');
-    }
-    else if (typeof btoa !== 'undefined') {
-        return btoa(s);
-    }
-    else {
-        throw new Error('no implementation provided for base64 encoding');
-    }
-}
-export function decodeBase64(s) {
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(s, 'base64').toString('utf8');
-    }
-    else if (typeof atob !== 'undefined') {
-        return atob(s);
-    }
-    else {
-        throw new Error('no implementation provided for base64 decoding');
-    }
-}
-export function wrapLine(s, columns, indent, newline) {
-    const parts = [];
-    const len = s.length;
-    const ilen = indent.length;
-    let pos = 0;
-    columns -= ilen;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if (pos + columns >= len - ilen) {
-            parts.push(s.substring(pos));
-            break;
-        }
-        let i = 0;
-        while (!isSpaceAt(s, pos + columns - i) && i < columns)
-            i++;
-        if (i === columns) {
-            // search ahead
-            i = 0;
-            while (!isSpaceAt(s, pos + columns + i) && pos + columns + i < len)
-                i++;
-            parts.push(s.substring(pos, pos + columns + i));
-            pos += columns + i + 1;
-        }
-        else {
-            parts.push(s.substring(pos, pos + columns - i));
-            pos += columns - i + 1;
-        }
-    }
-    return indent + parts.join(newline + indent);
-}
-export function lpad(s, char, length) {
-    const diff = length - s.length;
-    if (diff > 0) {
-        return repeat(char, diff) + s;
-    }
-    else {
-        return s;
-    }
-}
-export function rpad(s, char, length) {
-    const diff = length - s.length;
-    if (diff > 0) {
-        return s + repeat(char, diff);
-    }
-    else {
-        return s;
-    }
-}
-export function splitOnLast(s, find) {
-    const x = s.lastIndexOf(find);
-    if (x >= 0) {
-        return [s.substring(0, x), s.substring(x + find.length)];
-    }
-    else {
-        return [s];
-    }
-}
-export function splitOnFirst(s, find) {
-    const x = s.indexOf(find);
-    if (x >= 0) {
-        return [s.substring(0, x), s.substring(x + find.length)];
-    }
-    else {
-        return [s];
-    }
-}
-const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const UCWORDS = /[^a-zA-Z]([a-z])/g;
-const IS_BREAKINGWHITESPACE = /[^\t\n\r ]/;
-const IS_ALPHA = /[^a-zA-Z]/;
-const UCWORDSWS = /[ \t\r\n][a-z]/g;
-const ALPHANUM = /^[a-z0-9]+$/i;
-const DIGITS = /^[0-9]+$/;
-const STRIPTAGS = /<\/?[a-z]+[^>]*>/gi;
-const WSG = /[ \t\r\n]+/g;
-const SPLIT_LINES = /\r\n|\n\r|\n|\r/g;
-const CANONICALIZE_LINES = /\r\n|\n\r|\r/g;

package/dist/types/assert.d.ts

@@ -1,12 +0,0 @@
-/**
- *
- */
-import { type Pointer } from './generic';
-export type Assert<A extends true> = A extends never ? 'FAIL' : A extends true ? 'PASS' : 'FAIL';
-export type AssertNot<A extends false> = A extends never ? 'FAIL' : A extends false ? 'PASS' : 'FAIL';
-export type Extends<A, B> = A extends B ? true : false;
-export type Same<A, B> = Pointer<A> extends Pointer<B> ? Pointer<B> extends Pointer<A> ? true : false : false;
-export type NotSame<A, B> = Pointer<A> extends Pointer<B> ? Pointer<B> extends Pointer<A> ? false : true : true;
-export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-export type NotEquals<A, B> = Equals<A, B> extends true ? false : true;
-export type IsNever<T> = Pointer<T> extends Pointer<never> ? true : false;

package/dist/types/assert.js

@@ -1,13 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-export {};