inibase 1.0.0-rc.23 → 1.0.0-rc.24

package/dist/file.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 import { ComparisonOperator, FieldType } from "./index.js";
 export declare const isExists: (path: string) => Promise<boolean>;
-export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[], secretKey?: string | Buffer) => string | number | boolean;
+export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[], secretKey?: string | Buffer) => string | number | boolean | null;
 export declare const decode: (input: string | null | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => string | number | boolean | null | (string | number | null | boolean)[];
 export declare const get: (filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => Promise<[
-    Record<number, string | number | boolean | (string | number | boolean | (string | number | boolean)[])[]> | null,
+    Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null,
     number
 ]>;
 export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]> | Map<number, string | number | boolean | (string | number | boolean)[]>) => Promise<void>;
@@ -20,16 +20,16 @@ export declare const max: (filePath: string, lineNumbers?: number | number[]) =>
 export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
 export declare const sort: (filePath: string, sortDirection: 1 | -1 | "asc" | "desc", lineNumbers?: number | number[], _lineNumbersPerChunk?: number) => Promise<void>;
 export default class File {
-    static get: (filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | (string | number | boolean | (string | number | boolean)[])[]>, number]>;
+    static get: (filePath: string, lineNumbers?: number | number[] | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | (string | number | boolean)[] | null)[] | null> | null, number]>;
     static remove: (filePath: string, linesToDelete: number | number[]) => Promise<void>;
-    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | (string | number | boolean)[]>, number]>;
-    static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean)[] | Record<number, string | number | boolean | (string | number | boolean)[]> | Map<number, string | number | boolean | (string | number | boolean)[]>) => Promise<void>;
+    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, logicalOperator?: "and" | "or" | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, limit?: number | undefined, offset?: number | undefined, readWholeFile?: boolean | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null, number]>;
+    static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean | null)[] | Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | Map<number, string | number | boolean | (string | number | boolean)[]> | null) => Promise<void>;
     static count: (filePath: string) => Promise<number>;
-    static encode: (input: string | number | boolean | (string | number | boolean)[], secretKey?: string | Buffer) => string | number | boolean;
-    static decode: (input: string | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => string | number | boolean | (string | number | boolean)[];
+    static encode: (input: string | number | boolean | (string | number | boolean | null)[] | null, secretKey?: string | Buffer | undefined) => string | number | boolean | null;
+    static decode: (input: string | number | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, secretKey?: string | Buffer | undefined) => string | number | boolean | (string | number | boolean | null)[] | null;
     static isExists: (path: string) => Promise<boolean>;
-    static sum: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
-    static min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
-    static max: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+    static sum: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
+    static min: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
+    static max: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
     static append: (filePath: string, data: string | number | (string | number)[], startsAt?: number) => Promise<void>;
 }

package/dist/file.js

@@ -1,10 +1,12 @@
-import { open, rename, stat, writeFile } from "node:fs/promises";
+import { open, rename, stat, writeFile, appendFile, } from "node:fs/promises";
 import { createInterface } from "node:readline";
-import { detectFieldType, isArrayOfArrays, isNumber } from "./utils.js";
+import { detectFieldType, isArrayOfArrays, isNumber, isObject, } from "./utils.js";
 import { encodeID, comparePassword } from "./utils.server.js";
-const doesSupportReadLines = () => {
-    const [major, minor, patch] = process.versions.node.split(".").map(Number);
-    return major > 18 || (major === 18 && minor >= 11);
+const readLineInternface = (fileHandle) => {
+    return createInterface({
+        input: fileHandle.createReadStream(),
+        crlfDelay: Infinity,
+    });
 };
 export const isExists = async (path) => {
     try {
@@ -20,7 +22,7 @@ const secureString = (input) => {
     if (["true", "false"].includes(String(input)))
         return input ? 1 : 0;
     return typeof input === "string"
-        ? decodeURIComponent(input)
+        ? decodeURIComponent(input.replace(/%(?![0-9][0-9a-fA-F]+)/g, ""))
             .replaceAll("<", "&lt;")
             .replaceAll(">", "&gt;")
             .replaceAll(",", "%2C")
@@ -99,7 +101,9 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
                         : fieldChildrenType, undefined, secretKey))
                     : value;
         case "id":
-            return isNumber(value) ? encodeID(value, secretKey) : value;
+            return isNumber(value) && secretKey
+                ? encodeID(value, secretKey)
+                : value;
         default:
             return value;
     }
@@ -118,169 +122,108 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
         : input, fieldType, fieldChildrenType, secretKey);
 };
 export const get = async (filePath, lineNumbers, fieldType, fieldChildrenType, secretKey) => {
-    let fileHandle;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        let lines = new Map(), lineCount = 0;
-        if (!lineNumbers) {
-            for await (const line of rl)
-                lineCount++,
-                    lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-        }
-        else if (lineNumbers === -1) {
-            let lastLine;
-            for await (const line of rl)
-                lineCount++, (lastLine = line);
-            if (lastLine)
-                lines.set(lineCount, decode(lastLine, fieldType, fieldChildrenType, secretKey));
-        }
-        else {
-            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                lineCount++;
-                if (!lineNumbersArray.has(lineCount))
-                    continue;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    let lines = new Map(), lineCount = 0;
+    if (!lineNumbers) {
+        for await (const line of rl)
+            lineCount++,
                 lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-                lineNumbersArray.delete(lineCount);
-                if (!lineNumbersArray.size)
-                    break;
-            }
-        }
-        return [lines.size ? Object.fromEntries(lines) : null, lineCount];
     }
-    finally {
-        await fileHandle?.close();
+    else if (lineNumbers === -1) {
+        let lastLine = null;
+        for await (const line of rl)
+            lineCount++, (lastLine = line);
+        if (lastLine)
+            lines.set(lineCount, decode(lastLine, fieldType, fieldChildrenType, secretKey));
+    }
+    else {
+        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        for await (const line of rl) {
+            lineCount++;
+            if (!lineNumbersArray.has(lineCount))
+                continue;
+            lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
+            lineNumbersArray.delete(lineCount);
+            if (!lineNumbersArray.size)
+                break;
+        }
     }
+    await fileHandle.close();
+    return [lines.size ? Object.fromEntries(lines) : null, lineCount];
 };
 export const replace = async (filePath, replacements) => {
     if (await isExists(filePath)) {
-        const fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`;
-        let fileHandle, fileTempHandle, lineCount = 0;
-        try {
-            fileHandle = await open(filePath, "r");
-            fileTempHandle = await open(fileTempPath, "w+");
-            const rl = doesSupportReadLines()
-                ? fileHandle.readLines()
-                : createInterface({
-                    input: fileHandle.createReadStream(),
-                    crlfDelay: Infinity,
-                }), writeStream = fileTempHandle.createWriteStream();
-            if (typeof replacements === "object" && !Array.isArray(replacements)) {
-                if (!(replacements instanceof Map))
-                    replacements = new Map(Object.entries(replacements));
-                for await (const line of rl) {
-                    lineCount++;
-                    writeStream.write((replacements.has(lineCount.toString())
-                        ? replacements.get(lineCount.toString())
-                        : line) + "\n");
-                }
-                const newLinesNumbers = new Set([...replacements.keys()].filter((num) => num > lineCount));
-                if (newLinesNumbers.size) {
-                    if (Math.min(...newLinesNumbers) - lineCount - 1 > 1)
-                        writeStream.write("\n".repeat(Math.min(...newLinesNumbers) - lineCount - 1));
-                    for (const newLineNumber of newLinesNumbers)
-                        writeStream.write(replacements.get(newLineNumber.toString()) + "\n");
-                }
+        let lineCount = 0;
+        const fileHandle = await open(filePath, "r"), fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`, fileTempHandle = await open(fileTempPath, "w"), rl = readLineInternface(fileHandle), writeStream = fileTempHandle.createWriteStream();
+        if (isObject(replacements)) {
+            if (!(replacements instanceof Map))
+                replacements = new Map(Object.entries(replacements));
+            for await (const line of rl) {
+                lineCount++;
+                writeStream.write((replacements.has(lineCount.toString())
+                    ? replacements.get(lineCount.toString())
+                    : line) + "\n");
+            }
+            const newLinesNumbers = new Set([...replacements.keys()].filter((num) => num > lineCount));
+            if (newLinesNumbers.size) {
+                if (Math.min(...newLinesNumbers) - lineCount - 1 > 1)
+                    writeStream.write("\n".repeat(Math.min(...newLinesNumbers) - lineCount - 1));
+                for await (const newLineNumber of newLinesNumbers)
+                    writeStream.write(replacements.get(newLineNumber.toString()) + "\n");
             }
-            else
-                for await (const _line of rl)
-                    writeStream.write(replacements + "\n");
-            await rename(fileTempPath, filePath);
-        }
-        finally {
-            await fileHandle?.close();
-            await fileTempHandle?.close();
         }
+        else
+            for await (const _line of rl)
+                writeStream.write(replacements + "\n");
+        await fileHandle.close();
+        await fileTempHandle.close();
+        await rename(fileTempPath, filePath);
     }
-    else if (typeof replacements === "object" && !Array.isArray(replacements)) {
+    else if (isObject(replacements)) {
         if (!(replacements instanceof Map))
-            replacements = new Map(Object.entries(replacements));
+            replacements = new Map(Object.entries(replacements).map(([key, value]) => [Number(key), value]));
         await writeFile(filePath, (Math.min(...replacements.keys()) - 1 > 1
             ? "\n".repeat(Math.min(...replacements.keys()) - 1)
             : "") +
-            [...new Map([...replacements].sort(([a], [b]) => a - b)).values()].join("\n") +
+            Array.from(new Map([...replacements.entries()].sort(([keyA], [keyB]) => keyA - keyB)).values()).join("\n") +
             "\n");
     }
 };
 export const append = async (filePath, data, startsAt = 1) => {
-    let fileHandle;
-    try {
-        fileHandle = await open(filePath, "a");
-        const doesFileExists = await isExists(filePath);
-        const writeStream = fileHandle.createWriteStream();
-        if (doesFileExists) {
-            const currentNumberOfLines = await count(filePath);
-            if (startsAt - currentNumberOfLines - 1 > 0)
-                writeStream.write("\n".repeat(startsAt - currentNumberOfLines - 1));
-            if (Array.isArray(data)) {
-                for (const input of data)
-                    writeStream.write(input + "\n");
-            }
-            else
-                writeStream.write(data + "\n");
-        }
-        else {
-            if (startsAt - 1 > 0)
-                writeStream.write("\n".repeat(startsAt - 1));
-            if (Array.isArray(data)) {
-                for (const input of data)
-                    writeStream.write(input + "\n");
-            }
-            else
-                writeStream.write(data + "\n");
-        }
-    }
-    finally {
-        await fileHandle?.close();
-    }
+    let currentNumberOfLines = 0;
+    const doesFileExists = await isExists(filePath);
+    if (doesFileExists)
+        currentNumberOfLines = await count(filePath);
+    await appendFile(filePath, (currentNumberOfLines > 0
+        ? startsAt - currentNumberOfLines - 1 > 0
+            ? "\n".repeat(startsAt - currentNumberOfLines - 1)
+            : ""
+        : "") +
+        (Array.isArray(data) ? data.join("\n") : data) +
+        "\n");
 };
 export const remove = async (filePath, linesToDelete) => {
-    const fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`;
-    let fileHandle, fileTempHandle, lineCount = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        fileTempHandle = await open(fileTempPath, "w+");
-        const linesToDeleteArray = new Set(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]), rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            }), writeStream = fileTempHandle.createWriteStream();
-        for await (const line of rl) {
-            lineCount++;
-            if (!linesToDeleteArray.has(lineCount))
-                writeStream.write(`${line}\n`);
-        }
-        await rename(fileTempPath, filePath);
-    }
-    finally {
-        await fileTempHandle?.close();
-        await fileHandle?.close();
+    let lineCount = 0;
+    const fileHandle = await open(filePath, "r"), fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`, fileTempHandle = await open(fileTempPath, "w"), linesToDeleteArray = new Set(Array.isArray(linesToDelete)
+        ? linesToDelete.map(Number)
+        : [Number(linesToDelete)]), rl = readLineInternface(fileHandle), writeStream = fileTempHandle.createWriteStream();
+    for await (const line of rl) {
+        lineCount++;
+        if (!linesToDeleteArray.has(lineCount))
+            writeStream.write(`${line}\n`);
     }
+    await rename(fileTempPath, filePath);
+    await fileTempHandle.close();
+    await fileHandle.close();
 };
 export const count = async (filePath) => {
-    let fileHandle, lineCount = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        for await (const line of rl)
-            lineCount++;
-        return lineCount;
-    }
-    finally {
-        await fileHandle.close();
-    }
+    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
+    let lineCount = 0;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    for await (const line of rl)
+        lineCount++;
+    await fileHandle.close();
+    return lineCount;
 };
 const handleComparisonOperator = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
     if (Array.isArray(fieldType))
@@ -304,13 +247,21 @@ const handleComparisonOperator = (operator, originalValue, comparedAtValue, fiel
         case "!=":
             return !handleComparisonOperator("=", originalValue, comparedAtValue, fieldType);
         case ">":
-            return originalValue > comparedAtValue;
+            return (originalValue !== null &&
+                comparedAtValue !== null &&
+                originalValue > comparedAtValue);
         case "<":
-            return originalValue < comparedAtValue;
+            return (originalValue !== null &&
+                comparedAtValue !== null &&
+                originalValue < comparedAtValue);
         case ">=":
-            return originalValue >= comparedAtValue;
+            return (originalValue !== null &&
+                comparedAtValue !== null &&
+                originalValue >= comparedAtValue);
         case "<=":
-            return originalValue <= comparedAtValue;
+            return (originalValue !== null &&
+                comparedAtValue !== null &&
+                originalValue <= comparedAtValue);
         case "[]":
             return ((Array.isArray(originalValue) &&
                 Array.isArray(comparedAtValue) &&
@@ -334,153 +285,110 @@ const handleComparisonOperator = (operator, originalValue, comparedAtValue, fiel
     }
 };
 export const search = async (filePath, operator, comparedAtValue, logicalOperator, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
-    let fileHandle, RETURN = new Map(), lineCount = 0, foundItems = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        for await (const line of rl) {
-            lineCount++;
-            const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
-            if ((Array.isArray(operator) &&
-                Array.isArray(comparedAtValue) &&
-                ((logicalOperator &&
-                    logicalOperator === "or" &&
-                    operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
-                    operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
-                (!Array.isArray(operator) &&
-                    handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
-                foundItems++;
-                if (offset && foundItems < offset)
+    let RETURN = new Map(), lineCount = 0, foundItems = 0;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    for await (const line of rl) {
+        lineCount++;
+        const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
+        if ((Array.isArray(operator) &&
+            Array.isArray(comparedAtValue) &&
+            ((logicalOperator &&
+                logicalOperator === "or" &&
+                operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
+                operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
+            (!Array.isArray(operator) &&
+                handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
+            foundItems++;
+            if (offset && foundItems < offset)
+                continue;
+            if (limit && foundItems > limit)
+                if (readWholeFile)
                     continue;
-                if (limit && foundItems > limit)
-                    if (readWholeFile)
-                        continue;
-                    else
-                        break;
-                RETURN.set(lineCount, decodedLine);
-            }
+                else
+                    break;
+            RETURN.set(lineCount, decodedLine);
         }
-        return foundItems
-            ? [
-                Object.fromEntries(RETURN),
-                readWholeFile ? foundItems : foundItems - 1,
-            ]
-            : [null, 0];
-    }
-    finally {
-        await fileHandle?.close();
     }
+    await fileHandle.close();
+    return foundItems
+        ? [Object.fromEntries(RETURN), readWholeFile ? foundItems : foundItems - 1]
+        : [null, 0];
 };
 export const sum = async (filePath, lineNumbers) => {
-    let fileHandle, sum = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        if (lineNumbers) {
-            let lineCount = 0;
-            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                lineCount++;
-                if (!lineNumbersArray.has(lineCount))
-                    continue;
-                sum += +decode(line, "number");
-                lineNumbersArray.delete(lineCount);
-                if (!lineNumbersArray.size)
-                    break;
-            }
+    let sum = 0;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    if (lineNumbers) {
+        let lineCount = 0;
+        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        for await (const line of rl) {
+            lineCount++;
+            if (!lineNumbersArray.has(lineCount))
+                continue;
+            sum += +(decode(line, "number") ?? 0);
+            lineNumbersArray.delete(lineCount);
+            if (!lineNumbersArray.size)
+                break;
         }
-        else
-            for await (const line of rl)
-                sum += +decode(line, "number");
-        return sum;
-    }
-    finally {
-        await fileHandle?.close();
     }
+    else
+        for await (const line of rl)
+            sum += +(decode(line, "number") ?? 0);
+    await fileHandle.close();
+    return sum;
 };
 export const max = async (filePath, lineNumbers) => {
-    let fileHandle, max = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        if (lineNumbers) {
-            let lineCount = 0;
-            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                lineCount++;
-                if (!lineNumbersArray.has(lineCount))
-                    continue;
-                const lineContentNum = +decode(line, "number");
-                if (lineContentNum > max)
-                    max = lineContentNum;
-                lineNumbersArray.delete(lineCount);
-                if (!lineNumbersArray.size)
-                    break;
-            }
+    let max = 0;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    if (lineNumbers) {
+        let lineCount = 0;
+        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        for await (const line of rl) {
+            lineCount++;
+            if (!lineNumbersArray.has(lineCount))
+                continue;
+            const lineContentNum = +(decode(line, "number") ?? 0);
+            if (lineContentNum > max)
+                max = lineContentNum;
+            lineNumbersArray.delete(lineCount);
+            if (!lineNumbersArray.size)
+                break;
         }
-        else
-            for await (const line of rl) {
-                const lineContentNum = +decode(line, "number");
-                if (lineContentNum > max)
-                    max = lineContentNum;
-            }
-        return max;
-    }
-    finally {
-        await fileHandle?.close();
     }
+    else
+        for await (const line of rl) {
+            const lineContentNum = +(decode(line, "number") ?? 0);
+            if (lineContentNum > max)
+                max = lineContentNum;
+        }
+    await fileHandle.close();
+    return max;
 };
 export const min = async (filePath, lineNumbers) => {
-    let fileHandle, min = 0;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = doesSupportReadLines()
-            ? fileHandle.readLines()
-            : createInterface({
-                input: fileHandle.createReadStream(),
-                crlfDelay: Infinity,
-            });
-        if (lineNumbers) {
-            let lineCount = 0;
-            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                lineCount++;
-                if (!lineNumbersArray.has(lineCount))
-                    continue;
-                const lineContentNum = +decode(line, "number");
-                if (lineContentNum < min)
-                    min = lineContentNum;
-                lineNumbersArray.delete(lineCount);
-                if (!lineNumbersArray.size)
-                    break;
-            }
+    let min = 0;
+    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    if (lineNumbers) {
+        let lineCount = 0;
+        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        for await (const line of rl) {
+            lineCount++;
+            if (!lineNumbersArray.has(lineCount))
+                continue;
+            const lineContentNum = +(decode(line, "number") ?? 0);
+            if (lineContentNum < min)
+                min = lineContentNum;
+            lineNumbersArray.delete(lineCount);
+            if (!lineNumbersArray.size)
+                break;
         }
-        else
-            for await (const line of rl) {
-                const lineContentNum = +decode(line, "number");
-                if (lineContentNum < min)
-                    min = lineContentNum;
-            }
-        return min;
-    }
-    finally {
-        await fileHandle?.close();
     }
+    else
+        for await (const line of rl) {
+            const lineContentNum = +(decode(line, "number") ?? 0);
+            if (lineContentNum < min)
+                min = lineContentNum;
+        }
+    await fileHandle.close();
+    return min;
 };
 export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => { };
 export default class File {

package/dist/index.d.ts

@@ -59,7 +59,7 @@ declare global {
 export default class Inibase {
     folder: string;
     database: string;
-    table: string;
+    table: string | null;
     pageInfo: pageInfo;
     private cache;
     private totalItems;
@@ -69,8 +69,9 @@ export default class Inibase {
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string): Promise<Schema | undefined>;
     getField<Property extends keyof Field | "children">(keyPath: string, schema: Schema | Field, property?: Property): any;
-    validateData(data: Data | Data[], schema: Schema, skipRequiredField?: boolean): void;
-    formatData<dataType extends Data | Data[]>(data: dataType, schema: Schema, formatOnlyAvailiableKeys?: boolean): dataType extends Data ? Data : Data[];
+    private validateData;
+    private formatField;
+    private formatData;
     private getDefaultValue;
     private joinPathesContents;
     private getItemsFromSchema;
@@ -78,10 +79,10 @@ export default class Inibase {
     private applyCriteria;
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined): Promise<Data | null>;
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true): Promise<number[] | null>;
-    post(tableName: string, data: Data | Data[], options: Options | undefined, returnPostedData?: false): Promise<void | null>;
+    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: false): Promise<void | null>;
     post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
-    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria | undefined, options?: Options | undefined, returnPostedData?: false): Promise<void | null>;
+    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnPostedData?: false): Promise<void | null>;
     put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
     delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;