dymo-api 1.0.11 → 1.0.14

package/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: publish
+    runs-on: ubuntu-latest
+    environment: publish
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: "18"
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Build
+      run: npm run build
+
+    - name: Publish to npm
+      run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2024 TPEOficial LLC
-
-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.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 OpenAI
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# Official Dymo API Library for Node.
+
+You can see the library documentation by clicking [here](https://docs.tpeoficial.com/docs/dymo-api/getting-started/libraries?ch-pg=r-dm-node).

package/index.d.ts

@@ -1,11 +1,12 @@
-declare module 'dymo-api' {
-    class Configuration {
-        constructor({ rootApiKey, apiKey }?: { rootApiKey?: string; apiKey?: string });
-        getTokens(): Promise<any>;
+declare module "dymo-api" {
+    interface ConfigurationOptions {
+        rootApiKey?: string;
+        apiKey?: string;
     }
 
     class DymoAPI {
-        constructor(configuration: Configuration);
+        private configuration: ConfigurationOptions;
+        constructor(configuration?: ConfigurationOptions);
         initializeTokens(): Promise<void>;
         isValidData(data: any): Promise<any>;
         getPrayerTimes(data: any): Promise<any>;
@@ -14,5 +15,5 @@ declare module 'dymo-api' {
         newURLEncrypt(data: any): Promise<any>;
     }
 
-    export { Configuration, DymoAPI };
-}  
+    export { DymoAPI };
+}

package/index.ts

@@ -0,0 +1,35 @@
+import { ConfigurationOptions } from "dymo-api";
+
+class DymoAPI {
+    private configuration: ConfigurationOptions;
+
+    constructor(configuration: ConfigurationOptions = {}) {
+        this.configuration = configuration;
+    }
+
+    async initializeTokens(): Promise<void> {
+        // Implementación aquí
+    }
+
+    async isValidData(data: any): Promise<any> {
+        // Implementación aquí
+    }
+
+    async getPrayerTimes(data: any): Promise<any> {
+        // Implementación aquí
+    }
+
+    async inputSatinizer(data: any): Promise<any> {
+        // Implementación aquí
+    }
+
+    async isValidPwd(data: any): Promise<any> {
+        // Implementación aquí
+    }
+
+    async newURLEncrypt(data: any): Promise<any> {
+        // Implementación aquí
+    }
+}
+
+export { DymoAPI };

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "dymo-api",
-  "version": "1.0.11",
+  "version": "1.0.14",
   "description": "Flow system for Dymo API.",
-  "main": "index.js",
+  "main": "dist/index.js",
   "type": "module",
   "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/dymo-api.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
-    "url": "https://cdn.tpeoficial.com/static-download/libraries/npm/dymo-api.zip"
+    "url": "https://github.com/TPEOficial/dymo-api-node"
   },
   "keywords": [
     "Dymo",
@@ -17,9 +19,9 @@
     "Ciphera"
   ],
   "author": "TPEOficial LLC",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
-    "url": "https://support.tpeoficial.com/"
+    "url": "https://github.com/TPEOficial/dymo-api-node/issues"
   },
   "homepage": "https://dymo.tpeoficial.com",
   "dependencies": {
@@ -28,5 +30,11 @@
   "contributors": [
     "TPEOficial (https://github.com/TPEOficial)",
     "FJRG2007 (https://github.com/FJRG2007)"
-  ]
-}
+  ],
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/node": "^22.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  }
+}

package/{config.cjs → src/config.ts}

@@ -1,6 +1,8 @@
-module.exports = {
+const config = {
     lib: {
         name: "Dymo API",
         dir: "dymo-api"
     }
-}
+};
+
+export default config;

package/src/dymo-api.ts

@@ -0,0 +1,101 @@
+import axios from "axios";
+import * as PrivateAPI from "./private-api";
+import * as PublicAPI from "./public-api";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface TokensResponse {
+    organization: boolean;
+    root: boolean;
+    api: boolean;
+};
+
+interface Tokens {
+    root?: string;
+    api?: string;
+};
+
+class DymoAPI {
+    private organization: string | null;
+    private rootApiKey: string | null;
+    private apiKey: string | null;
+    private tokensResponse: TokensResponse | null;
+    private lastFetchTime: Date | null;
+
+    constructor({ organization = null, rootApiKey = null, apiKey = null }: { organization?: string | null; rootApiKey?: string | null; apiKey?: string | null }) {
+        if ((rootApiKey || apiKey) && !organization) throw customError(4000, "Organization is required when at least one token is specified.");
+        this.organization = organization;
+        this.rootApiKey = rootApiKey;
+        this.apiKey = apiKey;
+        this.tokensResponse = null;
+        this.lastFetchTime = null;
+        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
+    }
+
+    private async getTokens(): Promise<TokensResponse | undefined> {
+        const currentTime = new Date();
+        if (this.tokensResponse && this.lastFetchTime && (currentTime.getTime() - this.lastFetchTime.getTime()) < 5 * 60 * 1000) {
+            console.log(`[${config.lib.name}] Using cached tokens response.`);
+            return this.tokensResponse;
+        };
+
+        const tokens: Tokens = {};
+        if (this.rootApiKey) tokens.root = `Bearer ${this.rootApiKey}`;
+        if (this.apiKey) tokens.api = `Bearer ${this.apiKey}`;
+
+        try {
+            if (Object.keys(tokens).length === 0) return;
+
+            const response = await axios.post<{ data: TokensResponse }>(
+                "https://api.tpeoficial.com/v1/dvr/tokens",
+                { organization: this.organization, tokens }
+            );
+
+            if (tokens.root && response.data.data.root === false) throw customError(3000, "Invalid root token.");
+            if (tokens.api && response.data.data.api === false) throw customError(3000, "Invalid API token.");
+
+            this.tokensResponse = response.data.data;
+            this.lastFetchTime = currentTime;
+            console.log(`[${config.lib.name}] Tokens initialized successfully.`);
+            return this.tokensResponse;
+        } catch (error: any) {
+            throw customError(5000, error.message);
+        }
+    }
+
+    private async initializeTokens() {
+        try {
+            await this.getTokens();
+        } catch (error: any) {
+            throw customError(5000, `Error initializing tokens: ${error.message}`);
+        }
+    }
+
+    // FUNCTIONS / Private.
+    async isValidData(data: any): Promise<any> {
+        return await PrivateAPI.isValidData(this.apiKey, data);
+    }
+
+    // FUNCTIONS / Public.
+    async getPrayerTimes(data: any): Promise<any> {
+        return await PublicAPI.getPrayerTimes(data);
+    }
+
+    async satinizer(data: any): Promise<any> {
+        return await PublicAPI.satinizer(data);
+    }
+
+    async isValidPwd(data: any): Promise<any> {
+        return await PublicAPI.isValidPwd(data);
+    }
+
+    async newURLEncrypt(data: any): Promise<any> {
+        return await PublicAPI.newURLEncrypt(data);
+    }
+}
+
+export { DymoAPI };

package/src/private-api.ts

@@ -0,0 +1,49 @@
+import axios from "axios";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface PhoneData {
+    iso: any;
+    phone: string;
+};
+
+interface CreditCardData {
+    pan: string | number;
+    expirationDate?: string;
+    cvc?: string | number;
+    cvv?: string | number;
+};
+
+interface Data {
+    email?: string;
+    phone?: PhoneData;
+    domain?: string;
+    creditCard?: string | CreditCardData;
+    ip?: string;
+};
+
+export const isValidData = async (token: string | null, data: Data): Promise<any> => {
+    if (token === null) throw customError(3000, "Invalid private token.");
+    
+    let i = false;
+    for (const key in data) {
+        if (data.hasOwnProperty(key) && (key === "email" || key === "phone" || key === "domain" || key === "creditCard" || key === "ip")) {
+            i = true;
+            break;
+        }
+    }
+    if (!i) throw customError(1500, "You must provide at least one parameter.");
+    
+    try {
+        const response = await axios.post("https://api.tpeoficial.com/v1/private/secure/verify", data, {
+            headers: { "Authorization": token },
+        });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};

package/src/public-api.ts

@@ -0,0 +1,94 @@
+import axios from "axios";
+import config from "./config";
+
+const customError = (code: number, message: string): Error => {
+    const error = new Error();
+    return Object.assign(error, { code, message: `[${config.lib.name}] ${message}` });
+};
+
+interface PrayerTimesData {
+    lat?: number;
+    lon?: number;
+};
+
+interface InputSatinizerData {
+    input?: string;
+};
+
+interface IsValidPwdData {
+    email?: string;
+    password?: string;
+    bannedWords?: string | string[];
+    min?: number;
+    max?: number;
+};
+
+interface NewURLEncryptData {
+    url?: string;
+};
+
+export const getPrayerTimes = async (data: PrayerTimesData): Promise<any> => {
+    const { lat, lon } = data;
+    if (lat === undefined || lon === undefined) throw customError(1000, "You must provide a latitude and longitude.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/islam/prayertimes", { params: data });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const satinizer = async (data: InputSatinizerData): Promise<any> => {
+    const { input } = data;
+    if (input === undefined) throw customError(1000, "You must specify at least the input.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/inputSatinizer", { params: { input: encodeURIComponent(input) } });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const isValidPwd = async (data: IsValidPwdData): Promise<any> => {
+    let { email, password, bannedWords, min, max } = data;
+    if (password === undefined) throw customError(1000, "You must specify at least the password.");
+    const params: { [key: string]: any } = { password: encodeURIComponent(password) };
+
+    if (email) {
+        if (!/^[a-zA-Z0-9._\-+]+@?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/.test(email)) throw customError(1500, "If you provide an email address it must be valid.");
+        params.email = encodeURIComponent(email);
+    }
+
+    if (bannedWords) {
+        if (typeof bannedWords === "string") bannedWords = bannedWords.slice(1, -1).trim().split(",").map(item => item.trim());
+        
+        if (!Array.isArray(bannedWords) || bannedWords.length > 10) 
+            throw customError(1500, "If you provide a list of banned words; the list may not exceed 10 words and must be of array type.");
+        if (!bannedWords.every(word => typeof word === "string") || new Set(bannedWords).size !== bannedWords.length) 
+            throw customError(1500, "If you provide a list of banned words; all elements must be non-repeated strings.");
+        params.bannedWords = bannedWords;
+    }
+
+    if (min !== undefined && (!Number.isInteger(min) || min < 8 || min > 32)) throw customError(1500, "If you provide a minimum it must be valid.");
+    if (max !== undefined && (!Number.isInteger(max) || max < 32 || max > 100)) throw customError(1500, "If you provide a maximum it must be valid.");
+    if (min !== undefined) params.min = min;
+    if (max !== undefined) params.max = max;
+
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/validPwd", { params });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};
+
+export const newURLEncrypt = async (data: NewURLEncryptData): Promise<any> => {
+    const { url } = data;
+    if (url === undefined || (!url.startsWith("https://") && !url.startsWith("http://"))) throw customError(1500, "You must provide a valid url.");
+    try {
+        const response = await axios.get("https://api.tpeoficial.com/v1/public/url-encrypt", { params: data });
+        return response.data;
+    } catch (error: any) {
+        throw customError(5000, error.message);
+    }
+};

package/test/preview.js

@@ -1,18 +1,12 @@
-// npm install dymo-api
-// /* 1. */ const { Configuration, DymoAPI } = require("dymo-api");
-// /* 2. */ import { Configuration, DymoAPI } from "dymo-api"; // Coming Soon.
-// /* 3. */ import('dymo-api').then(({ Configuration, DymoAPI }) => { CODE HERE });
-// /* 4. */ const { Configuration, DymoAPI } = await import('dymo-api');
-import { Configuration, DymoAPI } from "../index.js";
 
-const configuration = new Configuration({
+import { DymoAPI } from "../index.js";
+
+// Creating the client for use.
+const dymo = new DymoAPI({
     /*rootApiKey: "ROOT_TOKEN_HERE",
     apiKey: "PRIVATE_TOKEN_HERE",*/
 });
 
-// Creating the client for use.
-const dymo = new DymoAPI(configuration);
-
 /*
 console.log(await dymo.isValidData({ email: "test@test.com", tel: "+34617509462", domain: "test.com", creditCard: "5110929780543845", ip: "52.94.236.248" })); // Private authorization required.
 console.log(await dymo.getPrayerTimes({ lat: "37.3755847689721", lon: "-4.457957889422379" })); // No authorization required.

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "./dist",
+        "rootDir": "./src"
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/index.js

@@ -1,20 +0,0 @@
-// This module is intended to unwrap Dymo API default export as named.
-// Keep top-level export same with static properties.
-// so that it can keep same with es module or cjs.
-
-/*const {
-    dymo
-} = dymoAPI;
-
-export {
-    dymoAPI as default
-}*/
-import pkg from './lib/dymo-api.cjs';
-
-const { Configuration: _Configuration, DymoAPI: _DymoAPI } = pkg;
-
-export { _Configuration as Configuration, _DymoAPI as DymoAPI };
-
-if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-    module.exports = { Configuration: _Configuration, DymoAPI: _DymoAPI };
-}

package/lib/dymo-api.cjs

@@ -1,64 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-/* INTERNALS */
-const privateAPI = require("./private-api.cjs");
-const publicAPI = require("./public-api.cjs");
-
-class Configuration {
-    constructor({ rootApiKey, apiKey } = {}) {
-        // If neither is provided, set them as empty strings.
-        this.rootApiKey = rootApiKey || null;
-        this.apiKey = apiKey || null;
-        this.tokensResponse = null; // Variable to store the response.
-        this.lastFetchTime = null; // Variable to store the time of last request.
-    }
-    async getTokens() {
-        // Checks if the response is available and if 5 minutes have passed since the last request.
-        const currentTime = new Date();
-        if (this.tokensResponse && this.lastFetchTime && currentTime - this.lastFetchTime < 5 * 60 * 1000) {
-            console.log(`[${config.lib.name}] Using cached tokens response.`);
-            return this.tokensResponse;
-        }
-        const tokens = {};
-        if (this.rootApiKey !== null) tokens.root = `Bearer ${this.rootApiKey}`;
-        if (this.apiKey !== null) tokens.api = `Bearer ${this.apiKey}`;
-        try {
-            if (Object.keys(tokens).length < 1) return;
-            const response = await axios.post('https://api.tpeoficial.com/v1/dvr/tokens', { tokens });
-            if (tokens.root && response.data.root === false) throw customError(3000, "Invalid root token.");
-            if (tokens.private && response.data.private === false) throw customError(3000, "Invalid private token.");
-            // Saves the response and the current request time.
-            this.tokensResponse = response.data;
-            this.lastFetchTime = currentTime;
-            console.log(`[${config.lib.name}] Tokens initialized successfully.`);
-            return response.data;
-        } catch (error) {
-            throw customError(5000, error.message);
-        }
-    }
-}
-
-class DymoAPI {
-    constructor(configuration) {
-        this.configuration = configuration;
-        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
-    }
-    async initializeTokens() {
-        try {
-            await this.configuration.getTokens();
-        } catch (error) {
-            throw customError(5000, `Error initializing tokens: ${error.message}`);
-        }
-    }
-    // FUNCTIONS / Private.
-    async isValidData(data) { return await privateAPI.isValidData(this.configuration.apiKey, data); }
-    // FUNCTIONS / Public.
-    async getPrayerTimes(data) { return await publicAPI.getPrayerTimes(data); }
-    async inputSatinizer(data) { return await publicAPI.inputSatinizer(data); }
-    async isValidPwd(data) { return await publicAPI.isValidPwd(data); }
-    async newURLEncrypt(data) { return await publicAPI.newURLEncrypt(data); }
-}
-
-module.exports = { Configuration, DymoAPI };

package/lib/private-api.cjs

@@ -1,21 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-exports.isValidData = async (token, data) => {
-    if (token === null) throw customError(3000, "Invalid private token.");
-    let i = false;
-    for (const key in data) {
-        if (data.hasOwnProperty(key) && (key === 'email' || key === 'tel' || key === 'domain' || key === 'creditCard' || key === 'ip')) {
-            i = true;
-            break;
-        }
-    }
-    if (!i) throw customError(1500, "You must provide at least one parameter.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/private/secure/verify`, { params: data, headers: { 'Authorization': token } });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};

package/lib/public-api.cjs

@@ -1,62 +0,0 @@
-const axios = require("axios");
-const config = require("../config.cjs");
-const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
-
-exports.getPrayerTimes = async (data) => {
-    const { lat, lon } = data;
-    if (!lat || !lon) throw customError(1000, "You must provide a latitude and longitude.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/islam/prayertimes`, { params: data });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.inputSatinizer = async (data) => {
-    const { input } = data;
-    if (!input) throw customError(1000, "You must specify at least the input.");
-    try {
-        const response = await axios.get('https://api.tpeoficial.com/v1/public/inputSatinizer', { params: { input: encodeURIComponent(input) } });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.isValidPwd = async (data) => {
-    var { email, password, bannedWords, min, max } = data;
-    if (!password) throw customError(1000, "You must specify at least the password.");
-    const params = {
-        password: encodeURIComponent(password),
-    };
-    if (email) {
-        if (!/^[a-zA-Z0-9._\-+]+@?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/.test(email)) throw customError(1500, "If you provide an email address it must be valid.");
-        params.email = encodeURIComponent(email);
-    }
-    if (bannedWords && typeof bannedWords === 'string') bannedWords = bannedWords.slice(1, -1).trim().split(',').map(item => item.trim());
-    if (bannedWords && (!Array.isArray(bannedWords) || bannedWords.length > 10)) throw customError(1500, "If you provide a list of banned words; the list may not exceed 10 words and must be of array type.");
-    if (bannedWords && (!bannedWords.every(word => typeof word === 'string') || new Set(bannedWords).size !== bannedWords.length)) throw customError(1500, "If you provide a list of banned words; all elements must be non-repeated strings.");
-    if (bannedWords) params.bannedWords = bannedWords;
-    if (min && (!Number.isInteger(min) && min < 8 && min > 32)) throw customError(1500, "If you provide a minimum it must be valid.");
-    if (max && (!Number.isInteger(max) && max < 32 && max > 100)) throw customError(1500, "If you provide a maximum it must be valid.");
-    if (min) params.min = min;
-    if (max) params.max = max;
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/validPwd`, { params });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-};
-
-exports.newURLEncrypt = async (data) => {
-    const { url } = data;
-    if (!url || (!url.startsWith("https://") && !url.startsWith("http://"))) throw customError(1500, "You must provide a valid url.");
-    try {
-        const response = await axios.get(`https://api.tpeoficial.com/v1/public/url-encrypt`, { params: data });
-        return response.data;
-    } catch (error) {
-        throw customError(5000, error.message);
-    }
-}