@puya/ts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 puyacodes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,8 @@
+# Timestamper
+This library provides timestamp and supports custom templates for its output file.
+
+# Install
+
+```
+npm i @puya/ts
+```

package/Timestamper.js

@@ -0,0 +1,188 @@
+const path = require("path");
+const fs = require("fs");
+const moment = require("jalali-moment");
+
+const version = '1.0.0';
+
+let default_options = {
+  locale: "en",
+  outputFileName: "info.json",
+  outPutFilePath: path.join(process.cwd(), "info.json"),
+  template: "{ \"ts\": \"{ts}\" }",
+  templatePath: "",
+  format: "YYYYMMDDHHmm",
+  inlineTemplate: "",
+  hasInlineTemplate: false
+};
+
+class TimestampError extends Error {
+  constructor(state, message) {
+    super();
+
+    this.state = state;
+    this.message = message;
+  }
+}
+
+function start(args) {
+  const result = {}
+
+  try {
+    const options = Array.isArray(args) ? parseArguments(args) : args;
+  
+    if (args.length !== 0) {
+      result.state = validateOptions(Object.assign(default_options, options));
+    } else {
+      result.state = "successful";
+    }
+  
+    if (result.state === "successful") {
+      result.options = Object.assign(default_options, options);
+      
+      const ts = generateTimestamp(options.locale, options.format);
+      const data = generateData(ts, result.options);
+    
+      writeOutput(data, result.options.outPutFilePath);
+      
+      result.success = true;
+    }
+  } catch (ex) {
+    if (ex instanceof TimestampError) {
+      result.state = ex.state;
+    }
+
+    result.err = ex;
+    result.success = false;
+  }
+
+  return result;
+}
+
+function parseArguments(args) {
+  if (args.length === 0) {
+    return default_options;
+  }
+
+  let i = 0;
+
+  do {
+    switch (args[i]) {
+      case '-o':
+        default_options.outputFileName = args[i + 1];
+        default_options.outPutFilePath = default_options.outputFileName
+          ? path.isAbsolute(default_options.outputFileName)
+            ? default_options.outputFileName
+            : path.join(process.cwd(), default_options.outputFileName)
+          : undefined;
+        i += 2;
+        break;
+      case '-t':
+        default_options.template = args[i + 1];
+        default_options.templatePath = default_options.template
+          ? path.isAbsolute(default_options.template)
+            ? default_options.template
+            : path.join(process.cwd(), default_options.template)
+          : undefined;
+        i += 2;
+        break;
+      case '-l':
+        default_options.locale = args[i + 1];
+        i += 2;
+        break;
+      case '-f':
+        default_options.format = args[i + 1];
+        i += 2;
+        break;
+      case '-i':
+        default_options.inlineTemplate = args[i + 1];
+        default_options.template = default_options.inlineTemplate;
+        default_options.hasInlineTemplate = true;
+        i += 2;
+        break;
+      default:
+        throw new Error(`Invalid argument provided: ${args[i]}`);
+    }
+  } while (i < args.length);
+
+  return default_options;
+}
+
+function validateOptions(options) {
+  const fileRegex = /^[\w,-]+\.[A-Za-z]{1,15}$/;
+
+  Object.entries(options).forEach(([key, value]) => {
+    if (value === undefined) {
+      throw new TimestampError(`${key}_required`, `${key} is required after -${key.slice(0, 1)}`);
+    }
+  });
+
+  if (!fileRegex.test(path.basename(options.outPutFilePath))) {
+    throw new TimestampError("invalid_filename", `Please enter a valid file name.`);
+  }
+
+  if (options.templatePath && !fs.existsSync(options.templatePath)) {
+    throw new TimestampError("template_not_exists", `Template file does not exist.`);
+  }
+
+  if (!isValidDateFormat(options.format)) {
+
+    throw new TimestampError("invalid_format", `Please enter a valid format.`);
+  }
+
+  if (options.inlineTemplate !== "") {
+    options.hasInlineTemplate = true;
+  }
+
+  if (options.hasInlineTemplate && options.inlineTemplate === "") {
+    throw new TimestampError("invalid_inline_template", `Please provide a valid inline template.`);
+  }
+
+  if (options.templatePath && options.inlineTemplate != "") {
+    throw new TimestampError("extra_template", `You can use only one template.`);
+  }
+
+  return "successful";
+}
+
+function generateTimestamp(locale, format) {
+  return moment().locale(locale).format(format);
+}
+
+function generateData(ts, {template, templatePath, inlineTemplate, hasInlineTemplate}) {
+  let data;
+
+  if (hasInlineTemplate) {
+    data = inlineTemplate;
+  } else if (templatePath) {
+    try {
+      data = fs.readFileSync(templatePath, { encoding: "utf8" });
+    } catch (error) {
+      throw new TimestampError("failed_to_read_file", `Failed to read template file at ${templatePath}`);
+    }
+  } else {
+    data = template;
+  }
+
+  if (!data.includes("{ts}")) {
+    throw new TimestampError("{ts}_placeholder_not_found", `Template does not contain {ts} placeholder.`);
+  }
+
+  return data.replace(/{ts}/g, ts);
+}
+
+function writeOutput(data, outPutFilePath) {
+  fs.writeFileSync(outPutFilePath, data);
+}
+
+function isValidDateFormat(format) {
+  try {
+    moment().format(format);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports.ts = start;
+module.exports.version = version;
+module.exports.TimestampError = TimestampError;

package/TimestamperCLI.js

@@ -0,0 +1,47 @@
+const { ts, version, TimestampError } = require("./Timestamper");
+
+function showHelp() {
+  console.log(`
+Timestamper v${version}
+  Usage: ts [options]
+
+  Options:
+    -v  --version         version
+    -l  --locale          locale to use for formatting the date/time. e.g. 'en' or 'fa' (default = en).
+    -o  --output          output file name where the result will be saved. default is info.json.
+    -t  --template        template file.
+    -f  --format          format string to use for formatting the date/time. default is "YYYYMMDDHHmm".
+    -i  --inline-template inline template string.
+
+  Examples:
+    ts
+    ts -l en -o result.json -t template.txt -f YYYYMMDDHHmmss
+    ts -l fa -o result.json -i "{ hash: '{ts}' }"
+    `);
+}
+
+function TimestamperCLI(args) {
+  try {
+    if (args.includes("--help") || args.includes("-?") || args.includes("/?")) {
+      showHelp();
+
+      return;
+    }
+
+    const result = ts(args);
+
+    if (result.success) {
+      console.log(`File ${result.options.outputFileName} generated at ${result.options.outPutFilePath}`);
+    } else {
+      if (result.err) {
+        throw result.err;
+      } else {
+        throw new TimestampError(result.state, result.message);
+      }
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+  }
+}
+
+module.exports = TimestamperCLI;

package/bin/ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+require(path.join(path.dirname(fs.realpathSync(__filename)), '../test'));

package/index.js

@@ -0,0 +1,4 @@
+const { ts } = require('./Timestamper')
+//const cli = require('./TimestamperCLI');
+
+module.exports = ts;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@puya/ts",
+  "version": "1.0.0",
+  "description": "This library provides timestamp and supports custom templates for its output file.",
+  "main": "index.js",
+  "bin": {
+    "ts": "bin/ts"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/puyacodes/ts.git"
+  },
+  "keywords": [
+    "puya",
+    "ts",
+    "timestamp",
+    "puyacodes",
+    "puyasoft"
+  ],
+  "author": "PuyaSoft",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/puyacodes/ts/issues"
+  },
+  "homepage": "https://github.com/puyacodes/ts#readme",
+  "dependencies": {
+    "jalali-moment": "^3.3.11"
+  },
+  "files": [
+    "test.js",
+    "Timestamper.js",
+    "TimestamperCLI.js",
+    "bin/ts"
+  ]
+}

package/test.js

@@ -0,0 +1,3 @@
+const cli = require('./TimestamperCLI');
+
+cli(process.argv.slice(2))