foxts 3.7.0 → 3.9.0-beta.1

package/dist/es/create-fixed-array.d.mts

@@ -1,6 +0,0 @@
-declare function createFixedArrayWithoutGC(length: number): readonly number[];
-declare function createFixedArrayWithGC(length: number): readonly number[];
-declare const createFixedArray: typeof createFixedArrayWithGC;
-declare const EMPTY_ARRAY: readonly number[];
-
-export { EMPTY_ARRAY, createFixedArray, createFixedArrayWithGC, createFixedArrayWithoutGC };

package/dist/es/detect-eol.d.mts

@@ -1,3 +0,0 @@
-declare function detectEol(str: string): "\n" | "\r\n";
-
-export { detectEol };

package/dist/es/escape-html.d.mts

@@ -1 +0,0 @@
-export * from 'fast-escape-html';

package/dist/es/escape-string-regexp.d.mts

@@ -1,11 +0,0 @@
-/**
- * Escape characters with special meaning either inside or outside character sets.
- * Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
- *
- * When the `unicodeMode` is `true` (default), the `-` character is escaped as `\x2d` to ensure compatibility with Unicode patterns, PCRE, and MongoDB.
- *
- * You should disable this option if you are using JavaScript regular expressions without the `u` flag.
- */
-declare function escapeStringRegexp(str: string, unicodeMode?: boolean): string;
-
-export { escapeStringRegexp };

package/dist/es/fast-ip-version.d.mts

@@ -1,6 +0,0 @@
-/**
- * If you know the input is probably an IP, you can use this function to quickly determine the version of the IP
- */
-declare function fastIpVersion(probablyIp: string): 4 | 6 | 0;
-
-export { fastIpVersion };

package/dist/es/fast-string-array-join.d.mts

@@ -1,6 +0,0 @@
-/**
- * A 200% faster join than the native `Array.prototype.join` for string arrays and string separator.
- */
-declare function fastStringArrayJoin(arr: string[], sep: string): string;
-
-export { fastStringArrayJoin };

package/dist/es/fifo.d.mts

@@ -1,18 +0,0 @@
-/** Checkout https://npm.im/fast-fifo if performance is critical */
-declare class FIFO<T> {
-    private head;
-    private tail;
-    $size: number;
-    constructor();
-    enqueue(value: T): void;
-    push: (value: T) => void;
-    dequeue(): T | undefined;
-    shift: () => T | undefined;
-    peek(): T | undefined;
-    clear(): void;
-    get size(): number;
-    get length(): number;
-    [Symbol.iterator](): Generator<T, void, unknown>;
-}
-
-export { FIFO };

package/dist/es/fnv1a.d.mts

@@ -1,3 +0,0 @@
-declare function fnv1a(s: string): number;
-
-export { fnv1a };

package/dist/es/fnv1a52.d.mts

@@ -1,12 +0,0 @@
-/**
- * FNV-1a Hash implementation
- * @author Travis Webb (tjwebb) <me@traviswebb.com>
- *
- * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
- *
- * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
- * and still making use of Javascript's 53-bit integer space.
- */
-declare function fnv1a52(str: string): number;
-
-export { fnv1a52 };

package/dist/es/guard.d.mts

@@ -1,20 +0,0 @@
-declare function not(arg: null): <T>(i: T | null) => i is T;
-declare function not(arg: undefined): <T>(i: T | undefined) => i is T;
-declare function not(arg: false): <T>(i: T | false) => i is T;
-declare function not(arg: 'nullish'): <T>(i: T | null | undefined) => i is T;
-declare function not(arg: 'falsy'): <T>(i: T | 0 | '' | false | null | undefined) => i is T;
-declare function is(arg: null): (i: unknown) => i is null;
-declare function is(arg: undefined): (i: unknown) => i is undefined;
-declare function is(arg: false): (i: unknown) => i is false;
-declare function is(arg: 'nullish'): (i: unknown) => i is null | undefined;
-declare function is(arg: 'falsy'): (i: unknown) => i is 0 | '' | false | null | undefined;
-declare function is(arg: 'truthy'): <T>(i: T | 0 | '' | false | null | undefined) => i is T;
-declare const isTruthy: <T>(i: T | 0 | "" | false | null | undefined) => i is T;
-declare const isFalsy: (i: unknown) => i is 0 | "" | false | null | undefined;
-declare const isNonNull: <T>(i: T | null) => i is T;
-declare const isNonNullish: <T>(i: T | null | undefined) => i is T;
-declare function nullthrow<T>(value: T | null | undefined, message?: string): T;
-declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
-declare function never(value: never, valueMetaName?: string): never;
-
-export { invariant, is, isFalsy, isNonNull, isNonNullish, isTruthy, never, not, nullthrow };

package/dist/es/headers-to-object.d.mts

@@ -1,5 +0,0 @@
-import { HeadersInitLike } from './merge-headers.mjs';
-
-declare function headersToObject(headers: HeadersInitLike | Headers): Record<string, string>;
-
-export { headersToObject };

package/dist/es/identity.d.mts

@@ -1,3 +0,0 @@
-declare function identity<T = any, R = T>(item: T): R;
-
-export { identity };

package/dist/es/is-probably-ip.d.mts

@@ -1,8 +0,0 @@
-/**
- * Check if a hostname is an IP. You should be aware that this only works
- * because `hostname` is already garanteed to be a valid hostname!
- */
-declare function isProbablyIpv4(hostname: string): boolean;
-declare function isProbablyIpv6(hostname: string): boolean;
-
-export { isProbablyIpv4, isProbablyIpv6 };

package/dist/es/merge-headers.d.mts

@@ -1,15 +0,0 @@
-type HeadersInitLike = string[][] | Record<string, string | readonly string[]> | Headers | null | undefined;
-type IncomingHttpHeadersLike = Record<string, string | string[] | undefined> | undefined | null;
-type OutgoingHttpHeadersLike = Record<string, number | string | string[] | undefined> | undefined | null;
-declare function mergeHeaders(dest: HeadersInitLike, source: HeadersInitLike, 
-/**
- * Filter function to determine which headers from source to merge.
- *
- * Can be an array/iterable of header names to include, or a filter callback that takes a header name.
- */
-sourceFilter?: Iterable<string> | null | undefined | ((headerName: string) => boolean)): Headers;
-declare function mergeNodeHttpHeaders(dest: IncomingHttpHeadersLike, source: IncomingHttpHeadersLike): IncomingHttpHeadersLike;
-declare function mergeNodeHttpHeaders(dest: OutgoingHttpHeadersLike, source: IncomingHttpHeadersLike | OutgoingHttpHeadersLike): OutgoingHttpHeadersLike;
-
-export { mergeHeaders, mergeNodeHttpHeaders };
-export type { HeadersInitLike, IncomingHttpHeadersLike, OutgoingHttpHeadersLike };

package/dist/es/noop.d.mts

@@ -1,12 +0,0 @@
-interface Noop<T = any> {
-    (...args: any[]): T;
-}
-declare const noop: Noop;
-declare const trueFn: Noop<true>;
-declare const falseFn: Noop<false>;
-declare const throwFn: Noop<never>;
-declare const asyncNoop: Noop<Promise<any>>;
-declare const asyncNeverFn: Noop<Promise<never>>;
-
-export { asyncNeverFn, asyncNoop, falseFn, noop, throwFn, trueFn };
-export type { Noop };

package/dist/es/once.d.mts

@@ -1,3 +0,0 @@
-declare function once<T>(fn: (() => T), prewarm?: boolean): (() => T);
-
-export { once };

package/dist/es/pick-random.d.mts

@@ -1,9 +0,0 @@
-/**
- * @param randomInt - a random generate function that accepts two arguments `min` and `max` and returns a random number between `min` and `max`
- */
-declare function createPickRandom(randomInt: (min: number, max: number) => number): <T>(data: T[] | readonly T[], count?: number) => T[];
-declare const pickRandom: <T>(data: T[] | readonly T[], count?: number) => T[];
-declare function createPickOne(randomInt: (min: number, max: number) => number): <T>(data: T[] | readonly T[]) => T;
-declare const pickOne: <T>(data: T[] | readonly T[]) => T;
-
-export { createPickOne, createPickRandom, pickOne, pickRandom };

package/dist/es/random-int.d.mts

@@ -1,7 +0,0 @@
-/**
- * @param random - a random generate function that returns a number between 0 and 1
- */
-declare function createRandomInt(random: () => number): (min: number, max: number) => number;
-declare const randomInt: (min: number, max: number) => number;
-
-export { createRandomInt, randomInt };

package/dist/es/repool.d.mts

@@ -1,19 +0,0 @@
-interface Reusifiable {
-    next: this | null;
-}
-/**
- * Repool is a class that allows you to reuse objects.
- *
- * Do not use this to store class instances, please use https://github.com/mcollina/reusify instead.
- */
-declare class Repool<T extends Reusifiable> {
-    private createObject;
-    private head;
-    private tail;
-    constructor(createObject: () => T);
-    get(): T;
-    release(obj: T): void;
-}
-
-export { Repool };
-export type { Reusifiable };

package/dist/es/retrie.d.mts

@@ -1,17 +0,0 @@
-import * as ___noop from './noop.mjs';
-
-interface BaseTrie {
-    [key: string]: Trie;
-}
-type Trie = BaseTrie | {
-    '': '';
-};
-declare function retrie(keywords: ArrayLike<string>, asPrefixes?: boolean): {
-    tree: BaseTrie;
-    add: (keywords: string, asPrefixes: boolean) => void;
-    toString: () => string;
-    toRe: () => RegExp;
-};
-declare function createRetrieKeywordFilter(keywords: ArrayLike<string>, asPrefixes?: boolean): ___noop.Noop<false> | ((string: string) => boolean);
-
-export { createRetrieKeywordFilter, retrie };

package/dist/es/serialized-memo.d.mts

@@ -1,60 +0,0 @@
-interface MemoizeStorageProvider {
-    has(key: string): boolean | Promise<boolean>;
-    get(key: string): string | undefined | PromiseLike<string | undefined>;
-    set(key: string, value: string, ttl: number): void | Promise<void>;
-    updateTtl?: (key: string, ttl: number) => void | Promise<void>;
-    delete(key: string): void | Promise<void>;
-}
-interface CreateMemoizeOptions {
-    /**
-     * When set to true, the memoize will always try run the function first.
-     * If promise resolved, it will update the cache.
-     * If promise rejected, it will try to get the value from cache, and return
-     * the cached value. If the cache is not available, it will throw the error.
-     */
-    onlyUseCachedIfFail?: boolean;
-    resetTtlOnHit?: boolean;
-    defaultTtl?: number;
-    onCacheUpdate?: (key: string, { humanReadableName }: {
-        humanReadableName: string;
-        isUseCachedIfFail: boolean;
-    }) => void;
-    onCacheMiss?: (key: string, { humanReadableName }: {
-        humanReadableName: string;
-        isUseCachedIfFail: boolean;
-    }) => void;
-    onCacheHit?: (key: string, { humanReadableName }: {
-        humanReadableName: string;
-        isUseCachedIfFail: boolean;
-    }) => void;
-    /** recommendation: import('hash-wasm').xxhash64 */
-    keyHasher?: (key: string) => Promise<string> | string;
-    /** recommendation: import('devalue').stringify */
-    argHasher: (args: any[]) => Promise<string> | string;
-}
-type SerializableValue = number | string | boolean | bigint | Date | RegExp | Set<SerializableValue> | SerializableValue[] | null | undefined | Map<SerializableValue, SerializableValue> | SerializableObject | /** TypedArray */ Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ArrayBuffer;
-interface SerializableObject {
-    [key: string]: SerializableValue;
-}
-interface MemoizeBaseOptions {
-    /**
-     * The time to live of the cache in milliseconds.
-     */
-    ttl?: number | null;
-    temporaryBypass?: boolean;
-}
-interface MemoizeOptionsWithCustomSerializer<T> extends MemoizeBaseOptions {
-    serializer: (value: T) => string;
-    deserializer: (cached: string) => T;
-}
-type MemoizeOptions<T> = T extends string ? MemoizeBaseOptions : MemoizeOptionsWithCustomSerializer<T>;
-/**
- * A factory function that returns a memoize function.
- *
- * Unlike common memoize function out there, this serialize the parameters and returned value
- * for easy storing with file system, SQLite, Redis, etc.
- */
-declare function createMemoize(storage: MemoizeStorageProvider, { onlyUseCachedIfFail, resetTtlOnHit, defaultTtl, onCacheUpdate, onCacheMiss, onCacheHit, keyHasher, argHasher }: CreateMemoizeOptions): <Args extends SerializableValue[], R>(fn: (...args: Args) => R | Promise<R>, opt?: MemoizeOptions<R>) => (...args: Args) => Promise<R>;
-
-export { createMemoize };
-export type { CreateMemoizeOptions, MemoizeOptions, MemoizeStorageProvider, SerializableValue };

package/dist/es/simple-string-hash.d.mts

@@ -1,3 +0,0 @@
-declare function simpleStringHash(payload: string): string;
-
-export { simpleStringHash };

package/dist/es/string-join.d.mts

@@ -1,3 +0,0 @@
-declare function stringJoin(arr: Array<string | null | undefined>, sep?: string, dedupe?: boolean): string;
-
-export { stringJoin };

package/dist/es/string-join.mjs

@@ -1 +0,0 @@
-import{fastStringArrayJoin as r}from"./fast-string-array-join.mjs";import{isNonNullish as t}from"./guard.mjs";function o(i,n=",",m=!1){return m&&(i=Array.from(new Set(i))),r(i.filter(t),n)}export{o as stringJoin};

package/dist/es/tagged.d.mts

@@ -1,6 +0,0 @@
-/**
- * @example import { tagged as html } from 'foxts/tagged';
- */
-declare function tagged(string: TemplateStringsArray, ...values: any[]): string;
-
-export { tagged };

package/dist/es/text-line-stream.d.mts

@@ -1,20 +0,0 @@
-interface TextLineStreamOptions {
-    /** Allow splitting by solo \r */
-    allowCR?: boolean;
-    skipEmptyLines?: boolean;
-}
-/** Transform a stream into a stream where each chunk is divided by a newline,
- * be it `\n` or `\r\n`. `\r` can be enabled via the `allowCR` option.
- *
- * ```ts
- * const res = await fetch('https://example.com');
- * const lines = res.body!
- *   .pipeThrough(new TextDecoderStream())
- *   .pipeThrough(new TextLineStream());
- * ```
- */
-declare class TextLineStream extends TransformStream<string, string> {
-    constructor({ allowCR, skipEmptyLines }?: TextLineStreamOptions);
-}
-
-export { TextLineStream };

package/dist/es/wait.d.mts

@@ -1,4 +0,0 @@
-declare function wait(ms: number): Promise<void>;
-declare function waitWithAbort(ms: number, signal: AbortSignal): Promise<void>;
-
-export { wait, waitWithAbort };