@yamato-daiwa/es-extensions-nodejs 0.0.2 → 0.10.0-alpha.0

package/Distributable/ObjectDataFilesProcessor/ObjectDataFilesProcessor.d.ts

@@ -0,0 +1,55 @@
+import { RawObjectDataProcessor } from "@yamato-daiwa/es-extensions";
+import type { PossiblyReadonlyParsedJSON } from "@yamato-daiwa/es-extensions";
+declare abstract class ObjectDataFilesProcessor {
+    static localization: ObjectDataFilesProcessor.Localization;
+    static processFile<ValidData extends PossiblyReadonlyParsedJSON>(compoundParameter: Readonly<{
+        filePath: string;
+        validDataSpecification: RawObjectDataProcessor.ObjectDataSpecification;
+        schema?: ObjectDataFilesProcessor.SupportedSchemas;
+        synchronously: false;
+    }>): Promise<ValidData>;
+    static processFile<ValidData extends PossiblyReadonlyParsedJSON>(compoundParameter: Readonly<{
+        filePath: string;
+        validDataSpecification: RawObjectDataProcessor.ObjectDataSpecification;
+        schema?: ObjectDataFilesProcessor.SupportedSchemas;
+        synchronously: true;
+    }>): ValidData;
+    static processFile(compoundParameter: Readonly<{
+        filePath: string;
+        schema?: ObjectDataFilesProcessor.SupportedSchemas;
+        synchronously: false;
+    }>): Promise<unknown>;
+    static processFile(compoundParameter: Readonly<{
+        filePath: string;
+        schema?: ObjectDataFilesProcessor.SupportedSchemas;
+        synchronously: true;
+    }>): unknown;
+    private static extractRawRawDataSynchronously;
+    private static extractRawRawDataAsynchronously;
+    private static parseRawData;
+}
+declare namespace ObjectDataFilesProcessor {
+    enum SupportedSchemas {
+        JSON = "JSON",
+        YAML = "YAML",
+        DOTENV = "DOTENV"
+    }
+    type Localization = Readonly<{
+        generateUnableToDecideDataParsingAlgorithmErrorMessage: (templateVariables: Localization.UnableToDecideDataParsingAlgorithmErrorMessage.TemplateVariables) => string;
+        generateUnsupportedFileNameExtension: (templateVariables: Localization.UnsupportedFileNameExtensionErrorMessage.TemplateVariables) => string;
+    }>;
+    namespace Localization {
+        namespace UnableToDecideDataParsingAlgorithmErrorMessage {
+            type TemplateVariables = Readonly<{
+                filePath: string;
+            }>;
+        }
+        namespace UnsupportedFileNameExtensionErrorMessage {
+            type TemplateVariables = Readonly<{
+                filePath: string;
+                fileNameLastExtensionWithoutLeadingDot: string;
+            }>;
+        }
+    }
+}
+export default ObjectDataFilesProcessor;

package/Distributable/ObjectDataFilesProcessor/ObjectDataFilesProcessor.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const yamljs_1 = __importDefault(require("yamljs"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const extractLastExtensionOfFileName_1 = __importDefault(require("../Temporary/extractLastExtensionOfFileName"));
+const isErrnoException_1 = __importDefault(require("../isErrnoException"));
+const FileNotFoundError_1 = __importDefault(require("../Errors/FileNotFoundError/FileNotFoundError"));
+const PathRefersToDirectoryNotFileError_1 = __importDefault(require("../Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileError"));
+const ObjectDataFilesProcessorLocalization_english_1 = __importDefault(require("./ObjectDataFilesProcessorLocalization.english"));
+class ObjectDataFilesProcessor {
+    static localization = ObjectDataFilesProcessorLocalization_english_1.default;
+    static processFile(compoundParameter) {
+        const filePath = compoundParameter.filePath;
+        let dataSchema;
+        if ((0, es_extensions_1.isNotUndefined)(compoundParameter.schema)) {
+            dataSchema = compoundParameter.schema;
+        }
+        else {
+            const fileNameLastExtensionWithoutLeadingDot = (0, extractLastExtensionOfFileName_1.default)({
+                targetPath: filePath, withLeadingDot: false
+            });
+            if ((0, es_extensions_1.isNull)(fileNameLastExtensionWithoutLeadingDot)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new es_extensions_1.InvalidParameterValueError({
+                        parameterName: "compoundParameter",
+                        parameterNumber: 1,
+                        messageSpecificPart: ObjectDataFilesProcessor.localization.
+                            generateUnableToDecideDataParsingAlgorithmErrorMessage({ filePath })
+                    }),
+                    title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                    occurrenceLocation: "ObjectDataFilesProcessor.processFile(compoundParameter)"
+                });
+            }
+            switch (fileNameLastExtensionWithoutLeadingDot) {
+                case "json": {
+                    dataSchema = ObjectDataFilesProcessor.SupportedSchemas.JSON;
+                    break;
+                }
+                case "yaml":
+                case "yml": {
+                    dataSchema = ObjectDataFilesProcessor.SupportedSchemas.YAML;
+                    break;
+                }
+                case "env": {
+                    dataSchema = ObjectDataFilesProcessor.SupportedSchemas.DOTENV;
+                    break;
+                }
+                default: {
+                    es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                        errorInstance: new es_extensions_1.InvalidParameterValueError({
+                            parameterName: "compoundParameter.filePath",
+                            parameterNumber: 1,
+                            messageSpecificPart: ObjectDataFilesProcessor.localization.generateUnsupportedFileNameExtension({
+                                filePath, fileNameLastExtensionWithoutLeadingDot
+                            })
+                        }),
+                        title: es_extensions_1.InvalidParameterValueError.localization.defaultTitle,
+                        occurrenceLocation: "ObjectDataFilesProcessor.processFile(compoundParameter)"
+                    });
+                }
+            }
+        }
+        if (compoundParameter.synchronously) {
+            return (0, es_extensions_1.isNotUndefined)(compoundParameter.validDataSpecification) ?
+                ObjectDataFilesProcessor.parseRawData({
+                    rawData: ObjectDataFilesProcessor.extractRawRawDataSynchronously(filePath),
+                    validDataSpecification: compoundParameter.validDataSpecification,
+                    dataSchema,
+                    filePathForLogging: filePath
+                }) :
+                ObjectDataFilesProcessor.parseRawData({
+                    rawData: ObjectDataFilesProcessor.extractRawRawDataSynchronously(filePath),
+                    dataSchema,
+                    filePathForLogging: filePath
+                });
+        }
+        return ObjectDataFilesProcessor.
+            extractRawRawDataAsynchronously(filePath).
+            then(async (rawData) => ((0, es_extensions_1.isNotUndefined)(compoundParameter.validDataSpecification) ?
+            ObjectDataFilesProcessor.parseRawData({
+                rawData,
+                validDataSpecification: compoundParameter.validDataSpecification,
+                dataSchema,
+                filePathForLogging: filePath
+            }) :
+            ObjectDataFilesProcessor.parseRawData({
+                rawData,
+                dataSchema,
+                filePathForLogging: filePath
+            })));
+    }
+    static extractRawRawDataSynchronously(filePath) {
+        const POTENTIAL_ERROR_OCCURRENCE_LOCATION = "ObjectDataFilesProcessor.processFile(compoundParameter)->" +
+            "ObjectDataFilesProcessor.extractRawRawDataSynchronously(filePath)";
+        let targetFileStatistics;
+        try {
+            targetFileStatistics = fs_1.default.statSync(filePath);
+        }
+        catch (error) {
+            if ((0, isErrnoException_1.default)(error) && error.code === "ENOENT") {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new FileNotFoundError_1.default({ filePath }),
+                    title: FileNotFoundError_1.default.localization.defaultTitle,
+                    occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION,
+                    innerError: error
+                });
+            }
+            throw error;
+        }
+        if (!targetFileStatistics.isFile()) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new PathRefersToDirectoryNotFileError_1.default({ targetPath: filePath }),
+                title: PathRefersToDirectoryNotFileError_1.default.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION
+            });
+        }
+        let rawData;
+        try {
+            rawData = fs_1.default.readFileSync(filePath, "utf-8");
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.FileReadingFailedError({ filePath }),
+                title: es_extensions_1.FileReadingFailedError.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION,
+                innerError: error
+            });
+        }
+        return rawData;
+    }
+    static async extractRawRawDataAsynchronously(filePath) {
+        const POTENTIAL_ERROR_OCCURRENCE_LOCATION = "ObjectDataFilesProcessor.processFile(compoundParameter)->" +
+            "ObjectDataFilesProcessor.extractRawRawDataAsynchronously(filePath)";
+        let targetFileStatistics;
+        try {
+            targetFileStatistics = await promises_1.default.stat(filePath);
+        }
+        catch (error) {
+            if ((0, isErrnoException_1.default)(error) && error.code === "ENOENT") {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new FileNotFoundError_1.default({ filePath }),
+                    title: FileNotFoundError_1.default.localization.defaultTitle,
+                    occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION,
+                    innerError: error
+                });
+            }
+            throw error;
+        }
+        if (!targetFileStatistics.isFile()) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new PathRefersToDirectoryNotFileError_1.default({ targetPath: filePath }),
+                title: PathRefersToDirectoryNotFileError_1.default.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION
+            });
+        }
+        let rawData;
+        try {
+            rawData = await promises_1.default.readFile(filePath, "utf-8");
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.FileReadingFailedError({ filePath }),
+                title: es_extensions_1.FileReadingFailedError.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION,
+                innerError: error
+            });
+        }
+        return rawData;
+    }
+    static parseRawData({ rawData, validDataSpecification, dataSchema, filePathForLogging }) {
+        const POTENTIAL_ERROR_OCCURRENCE_LOCATION = "ObjectDataFilesProcessor.processFile(compoundParameter)->" +
+            "ObjectDataFilesProcessor.parseRawData(compoundParameter)";
+        let parsedData;
+        try {
+            switch (dataSchema) {
+                case ObjectDataFilesProcessor.SupportedSchemas.JSON: {
+                    parsedData = JSON.parse(rawData);
+                    break;
+                }
+                case ObjectDataFilesProcessor.SupportedSchemas.YAML: {
+                    parsedData = yamljs_1.default.parse(rawData);
+                    break;
+                }
+                case ObjectDataFilesProcessor.SupportedSchemas.DOTENV: {
+                    parsedData = dotenv_1.default.parse(rawData);
+                }
+            }
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidExternalDataError({ mentionToExpectedData: filePathForLogging }),
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION,
+                innerError: error
+            });
+        }
+        if ((0, es_extensions_1.isUndefined)(validDataSpecification)) {
+            return parsedData;
+        }
+        const processingResult = es_extensions_1.RawObjectDataProcessor.process(parsedData, validDataSpecification);
+        if (processingResult.isRawDataInvalid) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidExternalDataError({
+                    customMessage: `The contents of file '${filePathForLogging}' does not matching with valid data specification:\n` +
+                        es_extensions_1.RawObjectDataProcessor.formatValidationErrorsList(processingResult.validationErrorsMessages)
+                }),
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                occurrenceLocation: POTENTIAL_ERROR_OCCURRENCE_LOCATION
+            });
+        }
+        return processingResult.processedData;
+    }
+}
+(function (ObjectDataFilesProcessor) {
+    let SupportedSchemas;
+    (function (SupportedSchemas) {
+        SupportedSchemas["JSON"] = "JSON";
+        SupportedSchemas["YAML"] = "YAML";
+        SupportedSchemas["DOTENV"] = "DOTENV";
+    })(SupportedSchemas = ObjectDataFilesProcessor.SupportedSchemas || (ObjectDataFilesProcessor.SupportedSchemas = {}));
+})(ObjectDataFilesProcessor || (ObjectDataFilesProcessor = {}));
+exports.default = ObjectDataFilesProcessor;

package/Distributable/ObjectDataFilesProcessor/ObjectDataFilesProcessorLocalization.english.d.ts

@@ -0,0 +1,4 @@
+import ObjectDataFilesProcessor from "./ObjectDataFilesProcessor";
+import Localization = ObjectDataFilesProcessor.Localization;
+declare const objectDataFilesProcessorLocalization__english: Localization;
+export default objectDataFilesProcessorLocalization__english;

package/Distributable/ObjectDataFilesProcessor/ObjectDataFilesProcessorLocalization.english.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const objectDataFilesProcessorLocalization__english = {
+    generateUnableToDecideDataParsingAlgorithmErrorMessage: ({ filePath }) => `Unable to decide the data parsing algorithm because target file path "${filePath}" has no the file name extension. ` +
+        "If it is intentional, specify \"dataSchema\" property with desired element of " +
+        "\"ObjectDataFilesProcessor.SupportedSchemas\" enumeration.",
+    generateUnsupportedFileNameExtension: ({ filePath, fileNameLastExtensionWithoutLeadingDot }) => `Target file "${filePath}" has unsupported file name extension "${fileNameLastExtensionWithoutLeadingDot}". ` +
+        "If it is intentional and this file including the data of known for \"ObjectDataFilesProcessor\" schema, please specify " +
+        "\"compoundParameter.dataSchema\" with desired element of \"ObjectDataFilesProcessor.SupportedSchemas\" enumeration."
+};
+exports.default = objectDataFilesProcessorLocalization__english;

package/Distributable/Temporary/appendCharacterIfItDoesNotPresentInLastPosition.d.ts

@@ -0,0 +1,4 @@
+export default function appendCharacterIfItDoesNotPresentInLastPosition(compoundParameter: Readonly<{
+    targetString: string;
+    trailingCharacter: string;
+}>): string;

package/Distributable/Temporary/appendCharacterIfItDoesNotPresentInLastPosition.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = appendCharacterIfItDoesNotPresentInLastPosition;
+function appendCharacterIfItDoesNotPresentInLastPosition(compoundParameter) {
+    const { targetString, trailingCharacter } = compoundParameter;
+    return targetString.endsWith(trailingCharacter) ? targetString : `${targetString}${trailingCharacter}`;
+}

package/Distributable/Temporary/extractLastExtensionOfFileName.d.ts

@@ -0,0 +1,9 @@
+export default function extractLastExtensionOfFileName(compoundParameter: Readonly<{
+    targetPath: string;
+    withLeadingDot: boolean;
+}>): string | null;
+export default function extractLastExtensionOfFileName(compoundParameter: Readonly<{
+    targetPath: string;
+    withLeadingDot: boolean;
+    mustThrowErrorIfLastPathSegmentHasNotDots: true;
+}>): string;

package/Distributable/Temporary/extractLastExtensionOfFileName.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractLastExtensionOfFileName;
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function extractLastExtensionOfFileName(compoundParameter) {
+    const lastFileNameExtensionWithoutLeadingDot = (/.(?<lastFileNameExtensionWithoutLeadingDot>\w+)$/u).
+        exec(compoundParameter.targetPath)?.
+        groups?.
+        lastFileNameExtensionWithoutLeadingDot;
+    if ((0, es_extensions_1.isUndefined)(lastFileNameExtensionWithoutLeadingDot)) {
+        if (compoundParameter.mustThrowErrorIfLastPathSegmentHasNotDots === true) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.UnexpectedEventError(`Contrary to expectations, the path ${compoundParameter.targetPath} has not the file name extension.`),
+                title: es_extensions_1.UnexpectedEventError.localization.defaultTitle,
+                occurrenceLocation: "extractLastExtensionOfFileName(compoundParameter)"
+            });
+        }
+        return null;
+    }
+    return lastFileNameExtensionWithoutLeadingDot;
+}

package/Distributable/index.d.ts

@@ -1,7 +1,22 @@
-/*!
- * @yamato-daiwa/es-extensions-nodejs v0.0.0
- * (c) 2021 Sole proprietorship "Yamato Daiwa" Takeshi Tokugawa
- * Released under the MIT License.
- */
-import NodeJS_Timer from "./DateTime/NodeJS_Timer";
-export { NodeJS_Timer };
+/*!
+ * @yamato-daiwa/es-extensions-nodejs v1.9
+ * (c) 2023 Yamato Daiwa Co., Ltd.
+ * Released under the MIT License.
+ */
+export { default as NodeJS_Timer } from "./DateTime/NodeJS_Timer";
+export { default as ConsoleApplicationLogger } from "./ConsoleApplicationLogger";
+export { default as DotEnvFilesGenerator } from "./DotEnvFilesGenerator";
+export { default as ConsoleCommandsParser } from "./ConsoleCommandsParser/ConsoleCommandsParser";
+export { default as consoleCommandsParserLocalization__english } from "./ConsoleCommandsParser/ConsoleCommandsParserLocalization.english";
+export { default as PathRefersToDirectoryNotFileError } from "./Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileError";
+export { default as pathRefersToDirectoryNotFileErrorLocalization__english } from "./Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileErrorLocalization.english";
+export { default as FileNotFoundError } from "./Errors/FileNotFoundError/FileNotFoundError";
+export { default as FileNotFoundErrorLocalization__English } from "./Errors/FileNotFoundError/FileNotFoundErrorLocalization.english";
+export { default as InvalidConsoleCommandError } from "./Errors/InvalidConsoleCommand/InvalidConsoleCommandError";
+export { default as InvalidConsoleCommandErrorLocalization__English } from "./Errors/InvalidConsoleCommand/InvalidConsoleCommandErrorLocalization.english";
+export { default as ImprovedPath } from "./ImprovedPath/ImprovedPath";
+export { default as ImprovedGlob } from "./ImprovedGlob";
+export { default as ImprovedFileSystem } from "./ImprovedFileSystem";
+export { default as ObjectDataFilesProcessor } from "./ObjectDataFilesProcessor/ObjectDataFilesProcessor";
+export { default as objectDataFilesProcessorLocalization__english } from "./ObjectDataFilesProcessor/ObjectDataFilesProcessorLocalization.english";
+export { default as isErrnoException } from "./isErrnoException";

package/Distributable/index.js

@@ -1,7 +1,45 @@
-/*!
- * @yamato-daiwa/es-extensions-nodejs v0.0.0
- * (c) 2021 Sole proprietorship "Yamato Daiwa" Takeshi Tokugawa
- * Released under the MIT License.
- */
-import NodeJS_Timer from "./DateTime/NodeJS_Timer";
-export { NodeJS_Timer };
+"use strict";
+/*!
+ * @yamato-daiwa/es-extensions-nodejs v1.9
+ * (c) 2023 Yamato Daiwa Co., Ltd.
+ * Released under the MIT License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErrnoException = exports.objectDataFilesProcessorLocalization__english = exports.ObjectDataFilesProcessor = exports.ImprovedFileSystem = exports.ImprovedGlob = exports.ImprovedPath = exports.InvalidConsoleCommandErrorLocalization__English = exports.InvalidConsoleCommandError = exports.FileNotFoundErrorLocalization__English = exports.FileNotFoundError = exports.pathRefersToDirectoryNotFileErrorLocalization__english = exports.PathRefersToDirectoryNotFileError = exports.consoleCommandsParserLocalization__english = exports.ConsoleCommandsParser = exports.DotEnvFilesGenerator = exports.ConsoleApplicationLogger = exports.NodeJS_Timer = void 0;
+var NodeJS_Timer_1 = require("./DateTime/NodeJS_Timer");
+Object.defineProperty(exports, "NodeJS_Timer", { enumerable: true, get: function () { return __importDefault(NodeJS_Timer_1).default; } });
+var ConsoleApplicationLogger_1 = require("./ConsoleApplicationLogger");
+Object.defineProperty(exports, "ConsoleApplicationLogger", { enumerable: true, get: function () { return __importDefault(ConsoleApplicationLogger_1).default; } });
+var DotEnvFilesGenerator_1 = require("./DotEnvFilesGenerator");
+Object.defineProperty(exports, "DotEnvFilesGenerator", { enumerable: true, get: function () { return __importDefault(DotEnvFilesGenerator_1).default; } });
+var ConsoleCommandsParser_1 = require("./ConsoleCommandsParser/ConsoleCommandsParser");
+Object.defineProperty(exports, "ConsoleCommandsParser", { enumerable: true, get: function () { return __importDefault(ConsoleCommandsParser_1).default; } });
+var ConsoleCommandsParserLocalization_english_1 = require("./ConsoleCommandsParser/ConsoleCommandsParserLocalization.english");
+Object.defineProperty(exports, "consoleCommandsParserLocalization__english", { enumerable: true, get: function () { return __importDefault(ConsoleCommandsParserLocalization_english_1).default; } });
+var PathRefersToDirectoryNotFileError_1 = require("./Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileError");
+Object.defineProperty(exports, "PathRefersToDirectoryNotFileError", { enumerable: true, get: function () { return __importDefault(PathRefersToDirectoryNotFileError_1).default; } });
+var PathRefersToDirectoryNotFileErrorLocalization_english_1 = require("./Errors/PathRefersToDirectoryNotFileError/PathRefersToDirectoryNotFileErrorLocalization.english");
+Object.defineProperty(exports, "pathRefersToDirectoryNotFileErrorLocalization__english", { enumerable: true, get: function () { return __importDefault(PathRefersToDirectoryNotFileErrorLocalization_english_1).default; } });
+var FileNotFoundError_1 = require("./Errors/FileNotFoundError/FileNotFoundError");
+Object.defineProperty(exports, "FileNotFoundError", { enumerable: true, get: function () { return __importDefault(FileNotFoundError_1).default; } });
+var FileNotFoundErrorLocalization_english_1 = require("./Errors/FileNotFoundError/FileNotFoundErrorLocalization.english");
+Object.defineProperty(exports, "FileNotFoundErrorLocalization__English", { enumerable: true, get: function () { return __importDefault(FileNotFoundErrorLocalization_english_1).default; } });
+var InvalidConsoleCommandError_1 = require("./Errors/InvalidConsoleCommand/InvalidConsoleCommandError");
+Object.defineProperty(exports, "InvalidConsoleCommandError", { enumerable: true, get: function () { return __importDefault(InvalidConsoleCommandError_1).default; } });
+var InvalidConsoleCommandErrorLocalization_english_1 = require("./Errors/InvalidConsoleCommand/InvalidConsoleCommandErrorLocalization.english");
+Object.defineProperty(exports, "InvalidConsoleCommandErrorLocalization__English", { enumerable: true, get: function () { return __importDefault(InvalidConsoleCommandErrorLocalization_english_1).default; } });
+var ImprovedPath_1 = require("./ImprovedPath/ImprovedPath");
+Object.defineProperty(exports, "ImprovedPath", { enumerable: true, get: function () { return __importDefault(ImprovedPath_1).default; } });
+var ImprovedGlob_1 = require("./ImprovedGlob");
+Object.defineProperty(exports, "ImprovedGlob", { enumerable: true, get: function () { return __importDefault(ImprovedGlob_1).default; } });
+var ImprovedFileSystem_1 = require("./ImprovedFileSystem");
+Object.defineProperty(exports, "ImprovedFileSystem", { enumerable: true, get: function () { return __importDefault(ImprovedFileSystem_1).default; } });
+var ObjectDataFilesProcessor_1 = require("./ObjectDataFilesProcessor/ObjectDataFilesProcessor");
+Object.defineProperty(exports, "ObjectDataFilesProcessor", { enumerable: true, get: function () { return __importDefault(ObjectDataFilesProcessor_1).default; } });
+var ObjectDataFilesProcessorLocalization_english_1 = require("./ObjectDataFilesProcessor/ObjectDataFilesProcessorLocalization.english");
+Object.defineProperty(exports, "objectDataFilesProcessorLocalization__english", { enumerable: true, get: function () { return __importDefault(ObjectDataFilesProcessorLocalization_english_1).default; } });
+var isErrnoException_1 = require("./isErrnoException");
+Object.defineProperty(exports, "isErrnoException", { enumerable: true, get: function () { return __importDefault(isErrnoException_1).default; } });

package/Distributable/isErrnoException.d.ts

@@ -0,0 +1,2 @@
+import ErrnoException = NodeJS.ErrnoException;
+export default function isErrnoException(error: unknown): error is ErrnoException;

package/Distributable/isErrnoException.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isErrnoException;
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+function isErrnoException(error) {
+    return (0, es_extensions_1.isArbitraryObject)(error) &&
+        error instanceof Error &&
+        ((0, es_extensions_1.isNumber)(error.errno, { mustConsiderNaN_AsNumber: false }) || (0, es_extensions_1.isUndefined)(error.errno)) &&
+        ((0, es_extensions_1.isString)(error.code) || (0, es_extensions_1.isUndefined)(error.code)) &&
+        ((0, es_extensions_1.isString)(error.path) || (0, es_extensions_1.isUndefined)(error.path)) &&
+        ((0, es_extensions_1.isString)(error.syscall) || (0, es_extensions_1.isUndefined)(error.syscall));
+}

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021-present, Sole proprietorship "Yamato Daiwa" Takeshi Tokugawa
+Copyright (c) 2023-present, Yamato Daiwa Co., Ltd.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,12 +1,60 @@
-# @yamato-daiwa/es-extensions-nodejs
+# Yamato Daiwa ES Extensions [YDEE] - NodeJS
+
+[![npm](https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/@yamato-daiwa/es-extensions)
+[![GitHub](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/CoreLibrary/Package)
+[![MIT](https://img.shields.io/badge/MIT-green?style=for-the-badge)](https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/CoreLibrary/Package/LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![IntelliJ IDEA plugin](https://img.shields.io/badge/IntelliJ_IDEA-000000.svg?style=for-the-badge&logo=intellij-idea&logoColor=white)](https://plugins.jetbrains.com/plugin/17638-yamato-daiwa-es-extensions)
+
+[![NPM Version](https://img.shields.io/npm/v/@yamato-daiwa/es-extensions)](https://www.npmjs.com/package/@yamato-daiwa/es-extensions-nodejs)
+![No any type](https://img.shields.io/badge/Type_safety-No_any-brightgreen.svg?style=flat)
+
+[![GitHub Sponsors](https://img.shields.io/badge/sponsor-30363D?style=for-the-badge&logo=GitHub-Sponsors&logoColor=#white)](https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions?sponsor=1)
+[![PAYPAL](https://img.shields.io/badge/PayPal-00457C?style=for-the-badge&logo=paypal&logoColor=white)](https://www.paypal.com/paypalme/tokugawatakeshi)
+[![LIBERAPAY](	https://img.shields.io/badge/Liberapay-F6C915?style=for-the-badge&logo=liberapay&logoColor=black)](https://liberapay.com/TokugawaT-YD)
 
 Additional to [@yamato-daiwa/es-extensions](https://www.npmjs.com/package/@yamato-daiwa/es-extensions) functionality 
-for Node.js environment. Helper functions and classes aimed to reduce the routine code. 
+for Node.js environment. 
+
+Helper functions and classes aimed to reduce the routine code.
 Build-in TypeScript type safety without `any` type.
+Oriented to TypeScript users investing the time to quality including type-safety.
 
 
 ## Installation
 
+The minor versions of **@yamato-daiwa/es-extensions-nodejs** and **@yamato-daiwa/es-extensions** must match.
+
 ```
-npm i @yamato-daiwa/es-extensions-nodejs -E
+npm i @yamato-daiwa/es-extensions-nodejs @yamato-daiwa/es-extensions -E
 ```
+
+
+## Functionality
+### Utils
+
+<dl>
+
+  <dt><a href="https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/NodeJS/Package/Documentation/Logging/ConsoleApplicationLogger/ConsoleApplicationLogger.md">ConsoleApplicationLogger</a></dt>
+  <dd>The implementation of <b>ILogger</b> interface for <a href="https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions/blob/master/CoreLibrary/Package/Documentation/Logging/Logger/Logger.md">Logger</a> facade and Node.js environment.</dd>
+
+  <dt><a href="https://ee.yamato-daiwa.com/NodeJS/ConsoleCommandsParser/ConsoleCommandsParser.english.html">ConsoleCommandsParser</a></dt>
+  <dd>Parsing and validating of CLI commands</dd>
+
+  <dt>isErrnoException</dt>
+  <dd>Type guard which checks is value compatible with <b>NodeJS.ErrnoException</b> interface.</dd>
+
+</dl>
+
+
+### Pre-made errors
+
+<dl>
+
+  <dt>FileNotFoundError</dt>
+  <dd>Intended to be thrown when the file which expected to exist was not found.</dd>
+  
+  <dt>InvalidConsoleCommandError</dt>
+  <dd>Intended to be thrown when the inputted console commands does not match with the manual.</dd>
+  
+</dl>

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@yamato-daiwa/es-extensions-nodejs",
-  "version": "0.0.2",
+  "version": "0.10.0-alpha.0",
   "description": "Additional to @yamato-daiwa/es-extensions functionality for Node.js environment. Helper functions and classes aimed to reduce the routine code. Build-in TypeScript type safety.",
   "keywords": [
     "nodejs",
+    "typescript",
     "utils",
     "logger"
   ],
@@ -12,31 +13,60 @@
     "email": "tokugawa.takesi@gmail.com"
   },
   "license": "MIT",
+  "homepage": "https://ee.yamato-daiwa.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TokugawaTakeshi/yamato_daiwa-es_extensions-nodejs"
+    "url": "git+https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions.git"
   },
   "bugs": {
-    "url": "https://github.com/TokugawaTakeshi/yamato_daiwa-es_extensions-nodejs/issues",
+    "url": "https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions.git/issues",
     "email": "tokugawa.takesi@gmail.com"
   },
   "main": "./Distributable/index.js",
+  "sideEffects": false,
   "types": "./Distributable/index.d.ts",
+  "files": [
+    "Distributable"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "peerDependencies": {
+    "@yamato-daiwa/es-extensions": "0.10.0-alpha.0"
+  },
+  "dependencies": {
+    "dotenv": "17.4.2",
+    "glob": "13.0.6",
+    "json5": "2.2.3",
+    "minimatch": "10.2.6",
+    "yamljs": "0.3.0"
+  },
   "devDependencies": {
-    "@types/mocha": "9.0.0",
-    "@types/node": "16.7.1",
-    "mocha": "9.1.0",
-    "ts-node": "10.2.1",
-    "typescript": "4.3.5",
-    "yamato-daiwa_code_quality_management": "0.0.17"
+    "@types/json5": "0.0.30",
+    "@types/node": "22.15.31",
+    "@types/yamljs": "0.2.34",
+    "@yamato-daiwa/es-extensions": "0.10.0-alpha.0",
+    "@yamato-daiwa/style_guides": "0.15.0",
+    "rimraf": "6.1.3",
+    "tsx": "4.23.15",
+    "typescript": "6.0.3"
   },
-  "engines": {
-    "node": ">=10.4.0"
+  "overrides": {
+    "yamljs": {
+      "argparse": "3.0.3"
+    }
+  },
+  "allowScripts": {
+    "esbuild": true
   },
   "scripts": {
-    "Lint": "eslint Source Tests"
+    "Check Types": "tsc --noEmit",
+    "Lint": "eslint",
+    "Run Tests": "node --require tsx/cjs --test \"Tests/Automated/**/*.test.ts\"",
+    "Rebuild Distributable Without Preliminary Cleaning": "tsc -p tsconfig.build.json",
+    "Rebuild Distributable": "rimraf --glob Distributable/* && tsc -p tsconfig.build.json",
+    "Rebuild Distributable and Realize Alpha": "npm run \"Rebuild Distributable\" && npm publish --tag alpha",
+    "Rebuild Distributable and Realize RC": "npm run \"Rebuild Distributable\" && npm publish --tag rc"
   },
-  "dependencies": {
-    "@yamato-daiwa/es-extensions": "1.0.1"
-  }
+  "funding": "https://github.com/TokugawaTakeshi/Yamato-Daiwa-ES-Extensions?sponsor=1"
 }

package/tsconfig.test.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": [ "Source/**/*", "Tests/**/*" ]
-}