@naturalcycles/js-lib 14.276.0 → 15.0.0

package/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -1,352 +0,0 @@
-import { _uniq } from '../array/array.util';
-import { _deepCopy, _sortObject, mergeJsonSchemaObjects } from '../index';
-import { JSON_SCHEMA_ORDER } from './jsonSchema.cnst';
-/**
- * Fluent (chainable) API to manually create Json Schemas.
- * Inspired by Joi
- */
-export const jsonSchema = {
-    any() {
-        return new JsonSchemaAnyBuilder({});
-    },
-    const(value) {
-        return new JsonSchemaAnyBuilder({
-            const: value,
-        });
-    },
-    null() {
-        return new JsonSchemaAnyBuilder({
-            type: 'null',
-        });
-    },
-    ref($ref) {
-        return new JsonSchemaAnyBuilder({
-            $ref,
-        });
-    },
-    enum(enumValues) {
-        return new JsonSchemaAnyBuilder({ enum: enumValues });
-    },
-    boolean() {
-        return new JsonSchemaAnyBuilder({
-            type: 'boolean',
-        });
-    },
-    buffer() {
-        return new JsonSchemaAnyBuilder({
-            instanceof: 'Buffer',
-        });
-    },
-    // number types
-    number() {
-        return new JsonSchemaNumberBuilder();
-    },
-    integer() {
-        return new JsonSchemaNumberBuilder().integer();
-    },
-    unixTimestamp() {
-        return new JsonSchemaNumberBuilder().unixTimestamp();
-    },
-    unixTimestamp2000() {
-        return new JsonSchemaNumberBuilder().unixTimestamp2000();
-    },
-    // string types
-    string() {
-        return new JsonSchemaStringBuilder();
-    },
-    dateString() {
-        return new JsonSchemaStringBuilder().date();
-    },
-    // email: () => new JsonSchemaStringBuilder().email(),
-    // complex types
-    object(props) {
-        return new JsonSchemaObjectBuilder().addProperties(props);
-    },
-    rootObject(props) {
-        return new JsonSchemaObjectBuilder().addProperties(props).$schemaDraft7();
-    },
-    array(itemSchema) {
-        return new JsonSchemaArrayBuilder(itemSchema);
-    },
-    tuple(items) {
-        return new JsonSchemaTupleBuilder(items);
-    },
-    oneOf(items) {
-        return new JsonSchemaAnyBuilder({
-            oneOf: items.map(b => b.build()),
-        });
-    },
-    allOf(items) {
-        return new JsonSchemaAnyBuilder({
-            allOf: items.map(b => b.build()),
-        });
-    },
-};
-export class JsonSchemaAnyBuilder {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    /**
-     * Used in ObjectBuilder to access schema.optionalProperty
-     */
-    getSchema() {
-        return this.schema;
-    }
-    $schema($schema) {
-        Object.assign(this.schema, { $schema });
-        return this;
-    }
-    $schemaDraft7() {
-        this.$schema('http://json-schema.org/draft-07/schema#');
-        return this;
-    }
-    $id($id) {
-        Object.assign(this.schema, { $id });
-        return this;
-    }
-    title(title) {
-        Object.assign(this.schema, { title });
-        return this;
-    }
-    description(description) {
-        Object.assign(this.schema, { description });
-        return this;
-    }
-    deprecated(deprecated = true) {
-        Object.assign(this.schema, { deprecated });
-        return this;
-    }
-    type(type) {
-        Object.assign(this.schema, { type });
-        return this;
-    }
-    default(v) {
-        Object.assign(this.schema, { default: v });
-        return this;
-    }
-    oneOf(schemas) {
-        Object.assign(this.schema, { oneOf: schemas });
-        return this;
-    }
-    allOf(schemas) {
-        Object.assign(this.schema, { allOf: schemas });
-        return this;
-    }
-    instanceof(of) {
-        this.schema.instanceof = of;
-        return this;
-    }
-    optional(optional = true) {
-        if (optional) {
-            this.schema.optionalField = true;
-        }
-        else {
-            this.schema.optionalField = undefined;
-        }
-        return this;
-    }
-    /**
-     * Produces a "clean schema object" without methods.
-     * Same as if it would be JSON.stringified.
-     */
-    build() {
-        return _sortObject(JSON.parse(JSON.stringify(this.schema)), JSON_SCHEMA_ORDER);
-    }
-    clone() {
-        return new JsonSchemaAnyBuilder(_deepCopy(this.schema));
-    }
-}
-export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'number',
-        });
-        this.int32 = () => this.format('int32');
-        this.int64 = () => this.format('int64');
-        this.float = () => this.format('float');
-        this.double = () => this.format('double');
-        this.unixTimestamp = () => this.format('unixTimestamp');
-        this.unixTimestamp2000 = () => this.format('unixTimestamp2000');
-        this.unixTimestampMillis = () => this.format('unixTimestampMillis');
-        this.unixTimestampMillis2000 = () => this.format('unixTimestampMillis2000');
-        this.utcOffset = () => this.format('utcOffset');
-        this.utcOffsetHours = () => this.format('utcOffsetHours');
-    }
-    integer() {
-        Object.assign(this.schema, { type: 'integer' });
-        return this;
-    }
-    multipleOf(multipleOf) {
-        Object.assign(this.schema, { multipleOf });
-        return this;
-    }
-    min(minimum) {
-        Object.assign(this.schema, { minimum });
-        return this;
-    }
-    exclusiveMin(exclusiveMinimum) {
-        Object.assign(this.schema, { exclusiveMinimum });
-        return this;
-    }
-    max(maximum) {
-        Object.assign(this.schema, { maximum });
-        return this;
-    }
-    exclusiveMax(exclusiveMaximum) {
-        Object.assign(this.schema, { exclusiveMaximum });
-        return this;
-    }
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum, maximum) {
-        Object.assign(this.schema, { minimum, maximum });
-        return this;
-    }
-    format(format) {
-        Object.assign(this.schema, { format });
-        return this;
-    }
-}
-export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'string',
-        });
-        this.email = () => this.format('email');
-        this.date = () => this.format('date');
-        this.url = () => this.format('url');
-        this.ipv4 = () => this.format('ipv4');
-        this.ipv6 = () => this.format('ipv6');
-        this.password = () => this.format('password');
-        this.id = () => this.format('id');
-        this.slug = () => this.format('slug');
-        this.semVer = () => this.format('semVer');
-        this.languageTag = () => this.format('languageTag');
-        this.countryCode = () => this.format('countryCode');
-        this.currency = () => this.format('currency');
-        this.trim = (trim = true) => this.transformModify('trim', trim);
-        this.toLowerCase = (toLowerCase = true) => this.transformModify('toLowerCase', toLowerCase);
-        this.toUpperCase = (toUpperCase = true) => this.transformModify('toUpperCase', toUpperCase);
-    }
-    pattern(pattern) {
-        Object.assign(this.schema, { pattern });
-        return this;
-    }
-    min(minLength) {
-        Object.assign(this.schema, { minLength });
-        return this;
-    }
-    max(maxLength) {
-        Object.assign(this.schema, { maxLength });
-        return this;
-    }
-    length(minLength, maxLength) {
-        Object.assign(this.schema, { minLength, maxLength });
-        return this;
-    }
-    format(format) {
-        Object.assign(this.schema, { format });
-        return this;
-    }
-    transformModify(t, add) {
-        if (add) {
-            this.schema.transform = _uniq([...(this.schema.transform || []), t]);
-        }
-        else {
-            this.schema.transform = this.schema.transform?.filter(s => s !== t);
-        }
-        return this;
-    }
-}
-export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
-    constructor() {
-        super({
-            type: 'object',
-            properties: {},
-            required: [],
-            additionalProperties: false,
-        });
-    }
-    addProperties(props) {
-        Object.entries(props).forEach(([k, builder]) => {
-            const schema = builder.build();
-            if (!schema.optionalField) {
-                this.schema.required.push(k);
-            }
-            else {
-                schema.optionalField = undefined;
-            }
-            this.schema.properties[k] = schema;
-        });
-        this.required(this.schema.required); // ensure it's sorted and _uniq
-        return this;
-    }
-    /**
-     * Ensures `required` is always sorted and _uniq
-     */
-    required(required) {
-        Object.assign(this.schema, { required });
-        this.schema.required = _uniq(required).sort();
-        return this;
-    }
-    addRequired(required) {
-        return this.required([...this.schema.required, ...required]);
-    }
-    minProps(minProperties) {
-        Object.assign(this.schema, { minProperties });
-        return this;
-    }
-    maxProps(maxProperties) {
-        Object.assign(this.schema, { maxProperties });
-        return this;
-    }
-    additionalProps(additionalProperties) {
-        Object.assign(this.schema, { additionalProperties });
-        return this;
-    }
-    baseDBEntity() {
-        Object.assign(this.schema.properties, {
-            id: { type: 'string' },
-            created: { type: 'number', format: 'unixTimestamp2000' },
-            updated: { type: 'number', format: 'unixTimestamp2000' },
-        });
-        return this.addRequired(['id', 'created', 'updated']);
-    }
-    extend(s2) {
-        const builder = new JsonSchemaObjectBuilder();
-        Object.assign(builder.schema, _deepCopy(this.schema));
-        mergeJsonSchemaObjects(builder.schema, s2.schema);
-        return builder;
-    }
-}
-export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
-    constructor(itemsSchema) {
-        super({
-            type: 'array',
-            items: itemsSchema.build(),
-        });
-    }
-    min(minItems) {
-        Object.assign(this.schema, { minItems });
-        return this;
-    }
-    max(maxItems) {
-        Object.assign(this.schema, { maxItems });
-        return this;
-    }
-    unique(uniqueItems) {
-        Object.assign(this.schema, { uniqueItems });
-        return this;
-    }
-}
-export class JsonSchemaTupleBuilder extends JsonSchemaAnyBuilder {
-    constructor(items) {
-        super({
-            type: 'array',
-            items: items.map(b => b.build()),
-            minItems: items.length,
-            maxItems: items.length,
-        });
-    }
-}

package/dist-esm/json-schema/jsonSchemas.js

@@ -1,6 +0,0 @@
-import { jsonSchema } from './jsonSchemaBuilder';
-export const baseDBEntityJsonSchema = jsonSchema.object({
-    id: jsonSchema.string(),
-    created: jsonSchema.unixTimestamp2000(),
-    updated: jsonSchema.unixTimestamp2000(),
-});

package/dist-esm/log/commonLogger.js

@@ -1,78 +0,0 @@
-// copy-pasted to avoid weird circular dependency
-const _noop = (..._args) => undefined;
-export const commonLogLevelNumber = {
-    log: 10,
-    warn: 20,
-    error: 30,
-};
-/**
- * SimpleLogger that does nothing (noop).
- *
- * @experimental
- */
-export const commonLoggerNoop = {
-    log: _noop,
-    warn: _noop,
-    error: _noop,
-};
-/**
- * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
- */
-export function commonLoggerMinLevel(logger, minLevel, mutate = false) {
-    const level = commonLogLevelNumber[minLevel];
-    if (mutate) {
-        if (level > commonLogLevelNumber['log']) {
-            logger.log = _noop;
-            if (level > commonLogLevelNumber['warn']) {
-                logger.warn = _noop;
-                if (level > commonLogLevelNumber['error']) {
-                    logger.error = _noop;
-                }
-            }
-        }
-        return logger;
-    }
-    if (level <= commonLogLevelNumber['log']) {
-        // All levels are kept
-        return logger;
-    }
-    if (level > commonLogLevelNumber['error']) {
-        // "Log nothing" logger
-        return commonLoggerNoop;
-    }
-    return {
-        log: _noop, // otherwise it is "log everything" logger (same logger as input)
-        warn: level <= commonLogLevelNumber['warn'] ? logger.warn.bind(logger) : _noop,
-        error: logger.error.bind(logger), // otherwise it's "log nothing" logger (same as noopLogger)
-    };
-}
-/**
- * Creates a "proxy" CommonLogger that pipes log messages to all provided sub-loggers.
- */
-export function commonLoggerPipe(loggers) {
-    return {
-        log: (...args) => loggers.forEach(logger => logger.log(...args)),
-        warn: (...args) => loggers.forEach(logger => logger.warn(...args)),
-        error: (...args) => loggers.forEach(logger => logger.error(...args)),
-    };
-}
-/**
- * Creates a "child" CommonLogger with prefix (one or multiple).
- */
-export function commonLoggerPrefix(logger, ...prefixes) {
-    return {
-        log: (...args) => logger.log(...prefixes, ...args),
-        warn: (...args) => logger.warn(...prefixes, ...args),
-        error: (...args) => logger.error(...prefixes, ...args),
-    };
-}
-/**
- * Creates a CommonLogger from a single function that takes `level` and `args`.
- */
-export function commonLoggerCreate(fn) {
-    return {
-        log: (...args) => fn('log', args),
-        warn: (...args) => fn('warn', args),
-        error: (...args) => fn('error', args),
-    };
-}

package/dist-esm/math/accumulatingAverage.js

@@ -1,32 +0,0 @@
-/**
- * Container that allows to accumulate average of a set of numbers,
- * without the need to store all of them in memory.
- *
- * @experimental
- */
-export class AccumulatingAverage {
-    constructor() {
-        this.total = 0;
-        this.count = 0;
-    }
-    /**
-     * Returns the current average.
-     * Returns 0 if no values have been added.
-     */
-    get average() {
-        if (this.count === 0)
-            return 0;
-        return this.total / this.count;
-    }
-    /**
-     * Adds a new value.
-     */
-    add(value) {
-        this.total += value;
-        this.count++;
-    }
-    reset() {
-        this.total = 0;
-        this.count = 0;
-    }
-}

package/dist-esm/math/math.util.js

@@ -1,85 +0,0 @@
-import { _assert } from '../error/assert';
-import { _sortNumbers } from '../number/number.util';
-/**
- * @returns Average of the array of numbers
- *
- * @example
- *
- * _average([1, 2, 3, 4])
- * // 2.5
- */
-export function _average(values) {
-    _assert(values.length, '_average is called on empty array');
-    let total = 0;
-    for (const n of values)
-        total += n;
-    return total / values.length;
-}
-/**
- * Same as _average, but safely returns null if input array is empty or nullish.
- */
-export function _averageOrNull(values) {
-    return values?.length ? _average(values) : null;
-}
-/**
- * valuesArray and weightsArray length is expected to be the same.
- */
-export function _averageWeighted(values, weights) {
-    let numerator = 0;
-    let denominator = 0;
-    // eslint-disable-next-line unicorn/no-for-loop
-    for (let i = 0; i < values.length; i++) {
-        numerator += values[i] * weights[i];
-        denominator += weights[i];
-    }
-    return numerator / denominator;
-}
-/**
- * @example
- *
- * _percentile([1, 2, 3, 4], 50)
- * // 2.5
- *
- * _percentile([1, 2, 3], 50)
- * // 2
- *
- * _percentile([1, 2, 3], 100)
- * // 3
- */
-export function _percentile(values, pc) {
-    const sorted = _sortNumbers(values);
-    // Floating pos in the range of [0; length - 1]
-    const pos = ((values.length - 1) * pc) / 100;
-    const dec = pos % 1;
-    const floorPos = Math.floor(pos);
-    const ceilPos = Math.ceil(pos);
-    return _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
-}
-/**
- * A tiny bit more efficient function than calling _percentile individually.
- */
-export function _percentiles(values, pcs) {
-    const r = {};
-    const sorted = _sortNumbers(values);
-    for (const pc of pcs) {
-        // Floating pos in the range of [0; length - 1]
-        const pos = ((values.length - 1) * pc) / 100;
-        const dec = pos % 1;
-        const floorPos = Math.floor(pos);
-        const ceilPos = Math.ceil(pos);
-        r[pc] = _averageWeighted([sorted[floorPos], sorted[ceilPos]], [1 - dec, dec]);
-    }
-    return r;
-}
-/**
- * @example
- *
- * _median([1, 2, 3])
- * // 2
- *
- * _median([1, 2, 3, 4])
- * // 2.5
- */
-export function _median(values) {
-    return _percentile(values, 50);
-}

package/dist-esm/math/sma.js

@@ -1,43 +0,0 @@
-/**
- * Implements a Simple Moving Average algorithm.
- */
-export class SimpleMovingAverage {
-    constructor(size, data = []) {
-        this.size = size;
-        this.data = data;
-        /**
-         * Next index of array to push to
-         */
-        this.nextIndex = 0;
-    }
-    /**
-     * Current average (calculated on the fly).
-     * Returns 0 (not undefined) for empty data.
-     */
-    get avg() {
-        if (this.data.length === 0)
-            return 0;
-        let total = 0;
-        for (const n of this.data)
-            total += n;
-        return total / this.data.length;
-    }
-    /**
-     * Push new value.
-     * Returns newly calculated average (using newly pushed value).
-     */
-    pushGetAvg(n) {
-        this.push(n);
-        return this.avg;
-    }
-    /**
-     * Push new value.
-     */
-    push(n) {
-        this.data[this.nextIndex] = n;
-        this.nextIndex =
-            this.nextIndex === this.size - 1
-                ? 0 // reset
-                : this.nextIndex + 1;
-    }
-}

package/dist-esm/math/stack.util.js

@@ -1,82 +0,0 @@
-import { _average, _percentile, _percentiles, _range } from '../index';
-/**
- * Implements a "round-robin" Stack ("first-in last-out" aka FILO) with a limited size.
- * Like an array of a fixed size. When it runs out of space - it starts writing on top of itself
- * from index 0.
- *
- *
- */
-export class Stack {
-    constructor(size) {
-        this.size = size;
-        /**
-         * Index of a slot to get written TO next.
-         * Currently this slot contains OLDEST item (if any).
-         */
-        this.nextIndex = 0;
-        this.items = [];
-    }
-    push(item) {
-        this.items[this.nextIndex] = item;
-        this.nextIndex = this.nextIndex === this.size - 1 ? 0 : this.nextIndex + 1;
-        return this;
-    }
-    /**
-     * Fill (overwrite) the whole Stack (all its items) with the passed `item`.
-     */
-    fill(item) {
-        _range(this.size).forEach(i => (this.items[i] = item));
-        return this;
-    }
-    /**
-     * Returns last items in the right order.
-     * Unlike raw `items` property that returns "items buffer" as-is (not ordered properly).
-     */
-    get itemsOrdered() {
-        if (this.items.length < this.size) {
-            // Buffer is not filled yet, just return it as-is
-            return this.items;
-        }
-        // Buffer was filled and started to "overwrite itself", will need to return 2 slices
-        return [...this.items.slice(this.nextIndex), ...this.items.slice(0, this.nextIndex)];
-    }
-}
-/**
- * Fixed-size FILO stack of Numbers.
- * Has convenience stat methods, e.g percentile, avg, etc.
- */
-export class NumberStack extends Stack {
-    avg() {
-        // _assert(this.items.length, 'NumberStack.avg cannot be called on empty stack')
-        return _average(this.items);
-    }
-    /**
-     * Returns null if Stack is empty.
-     */
-    avgOrNull() {
-        return this.items.length === 0 ? null : _average(this.items);
-    }
-    median() {
-        return _percentile(this.items, 50);
-    }
-    medianOrNull() {
-        return this.items.length === 0 ? null : _percentile(this.items, 50);
-    }
-    /**
-     * `pc` is a number from 0 to 100 inclusive.
-     */
-    percentile(pc) {
-        // _assert(this.items.length, 'NumberStack.percentile cannot be called on empty stack')
-        return _percentile(this.items, pc);
-    }
-    /**
-     * `pc` is a number from 0 to 100 inclusive.
-     * Returns null if Stack is empty.
-     */
-    percentileOrNull(pc) {
-        return this.items.length === 0 ? null : _percentile(this.items, pc);
-    }
-    percentiles(pcs) {
-        return _percentiles(this.items, pcs);
-    }
-}