tnp-core 21.0.166 → 21.0.167

package/full-dts/lodash.namespace.d.ts

@@ -0,0 +1,308 @@
+import type * as lodash from 'lodash';
+export declare namespace _ {
+    const add: typeof lodash.add;
+    const after: typeof lodash.after;
+    const ary: typeof lodash.ary;
+    const assign: typeof lodash.assign;
+    const assignIn: typeof lodash.assignIn;
+    const assignInWith: typeof lodash.assignInWith;
+    const assignWith: typeof lodash.assignWith;
+    const at: typeof lodash.at;
+    const attempt: typeof lodash.attempt;
+    const before: typeof lodash.before;
+    const bind: typeof lodash.bind;
+    const bindAll: typeof lodash.bindAll;
+    const bindKey: typeof lodash.bindKey;
+    const camelCase: typeof lodash.camelCase;
+    const capitalize: typeof lodash.capitalize;
+    const castArray: typeof lodash.castArray;
+    const ceil: typeof lodash.ceil;
+    const chain: typeof lodash.chain;
+    const chunk: typeof lodash.chunk;
+    const clamp: typeof lodash.clamp;
+    const clone: typeof lodash.clone;
+    const cloneDeep: typeof lodash.cloneDeep;
+    const cloneDeepWith: typeof lodash.cloneDeepWith;
+    const cloneWith: typeof lodash.cloneWith;
+    const compact: typeof lodash.compact;
+    const concat: typeof lodash.concat;
+    const cond: typeof lodash.cond;
+    const conforms: typeof lodash.conforms;
+    const conformsTo: typeof lodash.conformsTo;
+    const constant: typeof lodash.constant;
+    const countBy: typeof lodash.countBy;
+    const create: typeof lodash.create;
+    const curry: typeof lodash.curry;
+    const curryRight: typeof lodash.curryRight;
+    const debounce: typeof lodash.debounce;
+    const deburr: typeof lodash.deburr;
+    const defaultTo: typeof lodash.defaultTo;
+    const defaults: typeof lodash.defaults;
+    const defaultsDeep: typeof lodash.defaultsDeep;
+    const defer: typeof lodash.defer;
+    const delay: typeof lodash.delay;
+    const difference: typeof lodash.difference;
+    const differenceBy: typeof lodash.differenceBy;
+    const differenceWith: typeof lodash.differenceWith;
+    const divide: typeof lodash.divide;
+    const drop: typeof lodash.drop;
+    const dropRight: typeof lodash.dropRight;
+    const dropRightWhile: typeof lodash.dropRightWhile;
+    const dropWhile: typeof lodash.dropWhile;
+    const each: typeof lodash.each;
+    const eachRight: typeof lodash.eachRight;
+    const endsWith: typeof lodash.endsWith;
+    const entries: typeof lodash.entries;
+    const entriesIn: typeof lodash.entriesIn;
+    const eq: typeof lodash.eq;
+    const escape: typeof lodash.escape;
+    const escapeRegExp: typeof lodash.escapeRegExp;
+    const every: typeof lodash.every;
+    const extend: typeof lodash.extend;
+    const extendWith: typeof lodash.extendWith;
+    const fill: typeof lodash.fill;
+    const filter: typeof lodash.filter;
+    const find: typeof lodash.find;
+    const findIndex: typeof lodash.findIndex;
+    const findKey: typeof lodash.findKey;
+    const findLast: typeof lodash.findLast;
+    const findLastIndex: typeof lodash.findLastIndex;
+    const findLastKey: typeof lodash.findLastKey;
+    const first: typeof lodash.first;
+    const flatMap: typeof lodash.flatMap;
+    const flatMapDeep: typeof lodash.flatMapDeep;
+    const flatMapDepth: typeof lodash.flatMapDepth;
+    const flatten: typeof lodash.flatten;
+    const flattenDeep: typeof lodash.flattenDeep;
+    const flattenDepth: typeof lodash.flattenDepth;
+    const flip: typeof lodash.flip;
+    const floor: typeof lodash.floor;
+    const flow: typeof lodash.flow;
+    const flowRight: typeof lodash.flowRight;
+    const forEach: typeof lodash.forEach;
+    const forEachRight: typeof lodash.forEachRight;
+    const forIn: typeof lodash.forIn;
+    const forInRight: typeof lodash.forInRight;
+    const forOwn: typeof lodash.forOwn;
+    const forOwnRight: typeof lodash.forOwnRight;
+    const fromPairs: typeof lodash.fromPairs;
+    const functions: typeof lodash.functions;
+    const functionsIn: typeof lodash.functionsIn;
+    const get: typeof lodash.get;
+    const groupBy: typeof lodash.groupBy;
+    const gt: typeof lodash.gt;
+    const gte: typeof lodash.gte;
+    const has: typeof lodash.has;
+    const hasIn: typeof lodash.hasIn;
+    const head: typeof lodash.head;
+    const identity: typeof lodash.identity;
+    const inRange: typeof lodash.inRange;
+    const includes: typeof lodash.includes;
+    const indexOf: typeof lodash.indexOf;
+    const initial: typeof lodash.initial;
+    const intersection: typeof lodash.intersection;
+    const intersectionBy: typeof lodash.intersectionBy;
+    const intersectionWith: typeof lodash.intersectionWith;
+    const invert: typeof lodash.invert;
+    const invertBy: typeof lodash.invertBy;
+    const invoke: typeof lodash.invoke;
+    const invokeMap: typeof lodash.invokeMap;
+    const isArguments: typeof lodash.isArguments;
+    const isArray: typeof lodash.isArray;
+    const isArrayBuffer: typeof lodash.isArrayBuffer;
+    const isArrayLike: typeof lodash.isArrayLike;
+    const isArrayLikeObject: typeof lodash.isArrayLikeObject;
+    const isBoolean: typeof lodash.isBoolean;
+    const isBuffer: typeof lodash.isBuffer;
+    const isDate: typeof lodash.isDate;
+    const isElement: typeof lodash.isElement;
+    const isEmpty: typeof lodash.isEmpty;
+    const isEqual: typeof lodash.isEqual;
+    const isEqualWith: typeof lodash.isEqualWith;
+    const isError: typeof lodash.isError;
+    const isFinite: typeof lodash.isFinite;
+    const isFunction: typeof lodash.isFunction;
+    const isInteger: typeof lodash.isInteger;
+    const isLength: typeof lodash.isLength;
+    const isMap: typeof lodash.isMap;
+    const isMatch: typeof lodash.isMatch;
+    const isMatchWith: typeof lodash.isMatchWith;
+    const isNaN: typeof lodash.isNaN;
+    const isNative: typeof lodash.isNative;
+    const isNil: typeof lodash.isNil;
+    const isNull: typeof lodash.isNull;
+    const isNumber: typeof lodash.isNumber;
+    const isObject: typeof lodash.isObject;
+    const isObjectLike: typeof lodash.isObjectLike;
+    const isLeafObject: (value: unknown) => boolean;
+    const isPlainObject: typeof lodash.isPlainObject;
+    const isRegExp: typeof lodash.isRegExp;
+    const isSafeInteger: typeof lodash.isSafeInteger;
+    const isSet: typeof lodash.isSet;
+    const isString: typeof lodash.isString;
+    const isSymbol: typeof lodash.isSymbol;
+    const isTypedArray: typeof lodash.isTypedArray;
+    const isUndefined: typeof lodash.isUndefined;
+    const isWeakMap: typeof lodash.isWeakMap;
+    const isWeakSet: typeof lodash.isWeakSet;
+    const iteratee: typeof lodash.iteratee;
+    const join: typeof lodash.join;
+    const kebabCase: typeof lodash.kebabCase;
+    const keyBy: typeof lodash.keyBy;
+    const keys: typeof lodash.keys;
+    const keysIn: typeof lodash.keysIn;
+    const last: typeof lodash.last;
+    const lastIndexOf: typeof lodash.lastIndexOf;
+    const lowerCase: typeof lodash.lowerCase;
+    const lowerFirst: typeof lodash.lowerFirst;
+    const lt: typeof lodash.lt;
+    const lte: typeof lodash.lte;
+    const map: typeof lodash.map;
+    const mapKeys: typeof lodash.mapKeys;
+    const mapValues: typeof lodash.mapValues;
+    const matches: typeof lodash.matches;
+    const matchesProperty: typeof lodash.matchesProperty;
+    const max: typeof lodash.max;
+    const maxBy: typeof lodash.maxBy;
+    const mean: typeof lodash.mean;
+    const meanBy: typeof lodash.meanBy;
+    const memoize: typeof lodash.memoize;
+    const merge: typeof lodash.merge;
+    const mergeWith: typeof lodash.mergeWith;
+    const method: typeof lodash.method;
+    const methodOf: typeof lodash.methodOf;
+    const min: typeof lodash.min;
+    const minBy: typeof lodash.minBy;
+    const mixin: typeof lodash.mixin;
+    const multiply: typeof lodash.multiply;
+    const negate: typeof lodash.negate;
+    const noop: typeof lodash.noop;
+    const now: typeof lodash.now;
+    const nth: typeof lodash.nth;
+    const nthArg: typeof lodash.nthArg;
+    const omit: typeof lodash.omit;
+    const omitBy: typeof lodash.omitBy;
+    const once: typeof lodash.once;
+    const orderBy: typeof lodash.orderBy;
+    const over: typeof lodash.over;
+    const overArgs: typeof lodash.overArgs;
+    const overEvery: typeof lodash.overEvery;
+    const overSome: typeof lodash.overSome;
+    const pad: typeof lodash.pad;
+    const padEnd: typeof lodash.padEnd;
+    const padStart: typeof lodash.padStart;
+    const parseInt: typeof lodash.parseInt;
+    const partial: typeof lodash.partial;
+    const partialRight: typeof lodash.partialRight;
+    const partition: typeof lodash.partition;
+    const pick: typeof lodash.pick;
+    const pickBy: typeof lodash.pickBy;
+    const property: typeof lodash.property;
+    const propertyOf: typeof lodash.propertyOf;
+    const pull: typeof lodash.pull;
+    const pullAll: typeof lodash.pullAll;
+    const pullAllBy: typeof lodash.pullAllBy;
+    const pullAllWith: typeof lodash.pullAllWith;
+    const pullAt: typeof lodash.pullAt;
+    const random: typeof lodash.random;
+    const range: typeof lodash.range;
+    const rangeRight: typeof lodash.rangeRight;
+    const rearg: typeof lodash.rearg;
+    const reduce: typeof lodash.reduce;
+    const reduceRight: typeof lodash.reduceRight;
+    const reject: typeof lodash.reject;
+    const remove: typeof lodash.remove;
+    const repeat: typeof lodash.repeat;
+    const replace: typeof lodash.replace;
+    const rest: typeof lodash.rest;
+    const result: typeof lodash.result;
+    const reverse: typeof lodash.reverse;
+    const round: typeof lodash.round;
+    const sample: typeof lodash.sample;
+    const sampleSize: typeof lodash.sampleSize;
+    const set: typeof lodash.set;
+    const setWith: typeof lodash.setWith;
+    const shuffle: typeof lodash.shuffle;
+    const size: typeof lodash.size;
+    const slice: typeof lodash.slice;
+    const snakeCase: typeof lodash.snakeCase;
+    const some: typeof lodash.some;
+    const sortBy: typeof lodash.sortBy;
+    const sortedIndex: typeof lodash.sortedIndex;
+    const sortedIndexBy: typeof lodash.sortedIndexBy;
+    const sortedIndexOf: typeof lodash.sortedIndexOf;
+    const sortedLastIndex: typeof lodash.sortedLastIndex;
+    const sortedLastIndexBy: typeof lodash.sortedLastIndexBy;
+    const sortedLastIndexOf: typeof lodash.sortedLastIndexOf;
+    const sortedUniq: typeof lodash.sortedUniq;
+    const sortedUniqBy: typeof lodash.sortedUniqBy;
+    const split: typeof lodash.split;
+    const spread: typeof lodash.spread;
+    const startCase: typeof lodash.startCase;
+    const startsWith: typeof lodash.startsWith;
+    const stubArray: typeof lodash.stubArray;
+    const stubFalse: typeof lodash.stubFalse;
+    const stubObject: typeof lodash.stubObject;
+    const stubString: typeof lodash.stubString;
+    const stubTrue: typeof lodash.stubTrue;
+    const subtract: typeof lodash.subtract;
+    const sum: typeof lodash.sum;
+    const sumBy: typeof lodash.sumBy;
+    const tail: typeof lodash.tail;
+    const take: typeof lodash.take;
+    const takeRight: typeof lodash.takeRight;
+    const takeRightWhile: typeof lodash.takeRightWhile;
+    const takeWhile: typeof lodash.takeWhile;
+    const tap: typeof lodash.tap;
+    const template: typeof lodash.template;
+    const templateSettings: typeof lodash.templateSettings;
+    const throttle: typeof lodash.throttle;
+    const thru: typeof lodash.thru;
+    const times: typeof lodash.times;
+    const toArray: typeof lodash.toArray;
+    const toFinite: typeof lodash.toFinite;
+    const toInteger: typeof lodash.toInteger;
+    const toLength: typeof lodash.toLength;
+    const toLower: typeof lodash.toLower;
+    const toNumber: typeof lodash.toNumber;
+    const toPairs: typeof lodash.toPairs;
+    const toPairsIn: typeof lodash.toPairsIn;
+    const toPath: typeof lodash.toPath;
+    const toPlainObject: typeof lodash.toPlainObject;
+    const toSafeInteger: typeof lodash.toSafeInteger;
+    const toString: typeof lodash.toString;
+    const toUpper: typeof lodash.toUpper;
+    const transform: typeof lodash.transform;
+    const trim: typeof lodash.trim;
+    const trimEnd: typeof lodash.trimEnd;
+    const trimStart: typeof lodash.trimStart;
+    const truncate: typeof lodash.truncate;
+    const unary: typeof lodash.unary;
+    const unescape: typeof lodash.unescape;
+    const union: typeof lodash.union;
+    const unionBy: typeof lodash.unionBy;
+    const unionWith: typeof lodash.unionWith;
+    const uniq: typeof lodash.uniq;
+    const uniqBy: typeof lodash.uniqBy;
+    const uniqWith: typeof lodash.uniqWith;
+    const uniqueId: typeof lodash.uniqueId;
+    const unset: typeof lodash.unset;
+    const unzip: typeof lodash.unzip;
+    const unzipWith: typeof lodash.unzipWith;
+    const update: typeof lodash.update;
+    const updateWith: typeof lodash.updateWith;
+    const upperCase: typeof lodash.upperCase;
+    const upperFirst: typeof lodash.upperFirst;
+    const values: typeof lodash.values;
+    const valuesIn: typeof lodash.valuesIn;
+    const without: typeof lodash.without;
+    const words: typeof lodash.words;
+    const wrap: typeof lodash.wrap;
+    const xor: typeof lodash.xor;
+    const xorBy: typeof lodash.xorBy;
+    const xorWith: typeof lodash.xorWith;
+    const zip: typeof lodash.zip;
+    const zipObject: typeof lodash.zipObject;
+    const zipObjectDeep: typeof lodash.zipObjectDeep;
+    const zipWith: typeof lodash.zipWith;
+}

package/full-dts/lowdb/adapters/Memory.d.ts

@@ -0,0 +1,11 @@
+import { Adapter, SyncAdapter } from '../core/Low';
+export declare class Memory<T> implements Adapter<T> {
+    __data: T | null;
+    read(): Promise<T | null>;
+    write(obj: T): Promise<void>;
+}
+export declare class MemorySync<T> implements SyncAdapter<T> {
+    __data: T | null;
+    read(): T | null;
+    write(obj: T): void;
+}

package/full-dts/lowdb/adapters/client/LocalStorage.d.ts

@@ -0,0 +1,4 @@
+import { WebStorage } from './WebStorage';
+export declare class LocalStorage<T> extends WebStorage<T> {
+    constructor(key: string);
+}

package/full-dts/lowdb/adapters/client/SessionStorage.d.ts

@@ -0,0 +1,4 @@
+import { WebStorage } from './WebStorage';
+export declare class SessionStorage<T> extends WebStorage<T> {
+    constructor(key: string);
+}

package/full-dts/lowdb/adapters/client/WebStorage.d.ts

@@ -0,0 +1,8 @@
+import { SyncAdapter } from '../../core/Low';
+export declare class WebStorage<T> implements SyncAdapter<T> {
+    __key: string;
+    __storage: Storage;
+    constructor(key: string, storage: Storage);
+    read(): T | null;
+    write(obj: T): void;
+}

package/full-dts/lowdb/adapters/node/DataFile.d.ts

@@ -0,0 +1,25 @@
+import { PathLike } from 'fs';
+import { Adapter, SyncAdapter } from '../../core/Low';
+import { TextFile, TextFileSync } from './TextFile';
+export declare class DataFile<T> implements Adapter<T> {
+    __adapter: TextFile;
+    __parse: (str: string) => T;
+    __stringify: (data: T) => string;
+    constructor(filename: PathLike, { parse, stringify, }: {
+        parse: (str: string) => T;
+        stringify: (data: T) => string;
+    });
+    read(): Promise<T | null>;
+    write(obj: T): Promise<void>;
+}
+export declare class DataFileSync<T> implements SyncAdapter<T> {
+    __adapter: TextFileSync;
+    __parse: (str: string) => T;
+    __stringify: (data: T) => string;
+    constructor(filename: PathLike, { parse, stringify, }: {
+        parse: (str: string) => T;
+        stringify: (data: T) => string;
+    });
+    read(): T | null;
+    write(obj: T): void;
+}

package/full-dts/lowdb/adapters/node/JSONFile.d.ts

@@ -0,0 +1,8 @@
+import { PathLike } from 'fs';
+import { DataFile, DataFileSync } from './DataFile';
+export declare class JSONFile<T> extends DataFile<T> {
+    constructor(filename: PathLike);
+}
+export declare class JSONFileSync<T> extends DataFileSync<T> {
+    constructor(filename: PathLike);
+}

package/full-dts/lowdb/adapters/node/TextFile.d.ts

@@ -0,0 +1,17 @@
+import type { PathLike } from 'fs';
+import { Adapter, SyncAdapter } from '../../core/Low';
+import { Writer } from './steno';
+export declare class TextFile implements Adapter<string> {
+    __filename: PathLike;
+    __writer: Writer;
+    constructor(filename: PathLike);
+    read(): Promise<string | null>;
+    write(str: string): Promise<void>;
+}
+export declare class TextFileSync implements SyncAdapter<string> {
+    __tempFilename: PathLike;
+    __filename: PathLike;
+    constructor(filename: PathLike);
+    read(): string | null;
+    write(str: string): void;
+}

package/full-dts/lowdb/adapters/node/steno.d.ts

@@ -0,0 +1,13 @@
+export declare class Writer {
+    __filename: any;
+    __tempFilename: any;
+    __locked: boolean;
+    __prev: any;
+    __next: any;
+    __nextPromise: any;
+    __nextData: any;
+    __add(data: any): Promise<unknown>;
+    __write(data: any): Promise<void>;
+    constructor(filename: any);
+    write(data: any): Promise<unknown>;
+}

package/full-dts/lowdb/browser.d.ts

@@ -0,0 +1,3 @@
+export * from './adapters/client/LocalStorage';
+export * from './adapters/client/SessionStorage';
+export * from './presets/browser';

package/full-dts/lowdb/core/Low.d.ts

@@ -0,0 +1,24 @@
+export interface Adapter<T> {
+    read: () => Promise<T | null>;
+    write: (data: T) => Promise<void>;
+}
+export interface SyncAdapter<T> {
+    read: () => T | null;
+    write: (data: T) => void;
+}
+export declare class Low<T = unknown> {
+    adapter: Adapter<T>;
+    data: T;
+    constructor(adapter: Adapter<T>, defaultData: T);
+    read(): Promise<void>;
+    write(): Promise<void>;
+    update(fn: (data: T) => unknown): Promise<void>;
+}
+export declare class LowSync<T = unknown> {
+    adapter: SyncAdapter<T>;
+    data: T;
+    constructor(adapter: SyncAdapter<T>, defaultData: T);
+    read(): void;
+    write(): void;
+    update(fn: (data: T) => unknown): void;
+}

package/full-dts/lowdb/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adapters/Memory';
+export * from './core/Low';
+export * from './presets/node';

package/full-dts/lowdb/node.d.ts

@@ -0,0 +1,4 @@
+export * from './adapters/node/DataFile';
+export * from './adapters/node/JSONFile';
+export * from './adapters/node/TextFile';
+export * from './presets/node';

package/full-dts/lowdb/presets/browser.d.ts

@@ -0,0 +1,3 @@
+import { LowSync } from '../index';
+export declare function LocalStoragePreset<Data>(key: string, defaultData: Data): LowSync<Data>;
+export declare function SessionStoragePreset<Data>(key: string, defaultData: Data): LowSync<Data>;

package/full-dts/lowdb/presets/node.d.ts

@@ -0,0 +1,4 @@
+import type { PathLike } from 'fs';
+import { Low, LowSync } from '../core/Low';
+export declare function JSONFilePreset<Data>(filename: PathLike, defaultData: Data, useInMemory?: boolean): Promise<Low<Data>>;
+export declare function JSONFileSyncPreset<Data>(filename: PathLike, defaultData: Data, useInMemory?: boolean): LowSync<Data>;

package/full-dts/node-chalk-mock.d.ts

@@ -0,0 +1,2 @@
+import type { Chalk } from 'chalk';
+export declare const chalk: Chalk;

package/full-dts/node-path-mock.d.ts

@@ -0,0 +1,25 @@
+export declare const path: {
+    resolve: (pathToResovle: any) => any;
+    normalize: (pathArg: any) => any;
+    isAbsolute: (pathArg: any) => boolean;
+    join: () => any;
+    relative: (from: any, to: any) => any;
+    _makeLong: (path: any) => any;
+    dirname: (path: any) => any;
+    basename: (pathArg: any, ext: any) => any;
+    extname: (pathArg: any) => any;
+    format: (pathObject: any) => any;
+    parse: (pathArg: any) => {
+        root: string;
+        dir: string;
+        base: string;
+        ext: string;
+        name: string;
+    };
+    sep: string;
+    delimiter: string;
+    win32: {
+        normalize: (p: any) => any;
+    };
+    posix: any;
+};

package/full-dts/public-api.d.ts

@@ -0,0 +1,4 @@
+export * from './core-imports';
+export * from './core-models';
+export * from './core-config';
+export { Helpers } from './helpers';

package/full-dts/required-global-npm-packages.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TODO slowly refactor this.. only actually globally needed are:
+ * pm2, yarn, npm-run, ts-node ???
+ */
+export declare const requiredForDev: {
+    npm: ({
+        name: string;
+        version: string;
+        installName?: undefined;
+    } | {
+        name: string;
+        version?: undefined;
+        installName?: undefined;
+    } | {
+        name: string;
+        installName: string;
+        version?: undefined;
+    })[];
+    niceTools: ({
+        name: string;
+        platform?: undefined;
+        installName?: undefined;
+        isNotCli?: undefined;
+    } | {
+        name: string;
+        platform: string;
+        installName?: undefined;
+        isNotCli?: undefined;
+    } | {
+        name: string;
+        installName: string;
+        platform?: undefined;
+        isNotCli?: undefined;
+    } | {
+        name: string;
+        isNotCli: boolean;
+        platform?: undefined;
+        installName?: undefined;
+    })[];
+    programs: {
+        name: string;
+        website: string;
+    }[];
+};

package/full-dts/start-cli.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param argsv process.argsv
+ * @param filename needed if you want ipc communicaiton
+ */
+export declare function startCli(argsv: string[], filename: string): Promise<void>;
+export default startCli;

package/full-dts/taon-state-machine.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+export type JsPrimitive = string | number | boolean | null | undefined | bigint | symbol;
+export declare class TaonStateMachine<T extends JsPrimitive = JsPrimitive> {
+    private readonly config;
+    private _currentValue;
+    private readonly currentStateSubject;
+    readonly currentState$: Observable<{
+        currentState: T;
+        previousState: T;
+    }>;
+    constructor(config: {
+        debugMode?: boolean;
+        defaultValue: T;
+        allowedStateMap?: Map<T, T[]>;
+        modifyStateBeforeSetting?: (nextState: T, currentState: T, debugMode: boolean) => T;
+        effect?: (nextState: T, previousState: T, debugMode: boolean) => void | Promise<void>;
+        throwOnInvalidTransition?: boolean;
+    });
+    get debugMode(): boolean;
+    get currentValue(): T;
+    canSet(nextStateRaw: T): boolean;
+    set(nextStateRaw: T): boolean;
+}

package/full-dts/utils-binary.d.ts

@@ -0,0 +1,68 @@
+import { Blob } from 'buffer';
+import { CoreModels } from './core-models';
+export declare enum DbBinaryFormatEnum {
+    Blob = "Blob",
+    File = "File",
+    string = "string",
+    Buffer = "Buffer"
+}
+export type DbBinaryFormatForBrowser = Blob | File | string;
+export type DbBinaryFormatForBackend = Buffer;
+/**
+ * Binary format that can be stored in database
+ *
+ * for nodejs => Buffer
+ * for sql.js => string (shoulb be blob - but not supported)
+ *
+ */
+export type DbBinaryFormat = DbBinaryFormatForBrowser | DbBinaryFormatForBackend;
+export declare namespace UtilsBinary {
+    /**
+     * This is for BROWSER ONLY
+     *
+     * @param buffer
+     * @param contentType
+     * @returns
+     */
+    function arrayBufferToBlob(buffer: ArrayBuffer, contentType: CoreModels.ContentType): Promise<Blob>;
+    /**
+     * This is for BROWSER ONLY
+     * @param blob
+     * @returns
+     */
+    function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
+    /**
+     * it is revers to base64toBlob
+     * @param blob
+     * @returns
+     */
+    function blobToBase64(blob: Blob): Promise<string>;
+    /**
+     * it is revers to blobToBase64()
+     * @param base64Data
+     * @returns
+     */
+    function base64toBlob(base64Data: string, contentTypeOverride?: CoreModels.ContentType): Promise<Blob>;
+    function base64toDbBinaryFormat(text: string): Promise<DbBinaryFormat>;
+    function dbBinaryFormatToBase64(binaryFormat: DbBinaryFormat): Promise<string>;
+    function textToDbBinaryFormat(text: string): Promise<DbBinaryFormat>;
+    function dbBinaryFormatToText(binaryFormat: DbBinaryFormat): Promise<string>;
+    function base64toBuffer(base64Data: string, contentTypeOverride?: CoreModels.ContentType): Promise<Buffer>;
+    function bufferToBase64(bufferData: Buffer): Promise<string>;
+    function fileToBlob(file: File): Promise<Blob>;
+    function blobToFile(blob: Blob, nameForFile?: string): Promise<File>;
+    function blobToBuffer(blob: Blob): Promise<Buffer>;
+    function bufferToBlob(buffer: Buffer): Promise<Blob>;
+    function textToBuffer(text: string, type?: CoreModels.ContentType): Promise<Buffer>;
+    function bufferToText(buffer: Buffer): Promise<string>;
+    function textToBlob(text: string, type?: CoreModels.ContentType): Promise<Blob>;
+    function blobToText(blob: Blob): Promise<string>;
+    function textToFile(text: string, fileRelativePathOrName: string): Promise<File>;
+    function fileToText(file: File): Promise<string>;
+    function jsonToBlob(jsonObj: object): Promise<Blob>;
+    /**
+     * TODO NOT TESTED
+     */
+    function blobToJson(blob: Blob): Promise<string>;
+    function getBlobFrom(url: string): Promise<Blob>;
+}