ofsc-utility 1.0.0

package/dist/case-converters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Case conversion utilities
+ */
+export declare function toCamelCase(str: string): string;
+export declare function toPascalCase(str: string): string;
+export declare function toSnakeCase(str: string): string;
+export declare function toKebabCase(str: string): string;
+export declare function toTitleCase(str: string): string;
+export declare function toSentenceCase(str: string): string;
+export declare function toConstantCase(str: string): string;
+export declare function toDotCase(str: string): string;

package/dist/case-converters/index.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Case conversion utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.toKebabCase = toKebabCase;
+exports.toTitleCase = toTitleCase;
+exports.toSentenceCase = toSentenceCase;
+exports.toConstantCase = toConstantCase;
+exports.toDotCase = toDotCase;
+function toCamelCase(str) {
+    if (!str)
+        return '';
+    return str
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+        .replace(/\s+/g, '')
+        .replace(/[_-]/g, '');
+}
+function toPascalCase(str) {
+    if (!str)
+        return '';
+    return str
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+        .replace(/\s+/g, '')
+        .replace(/[_-]/g, '');
+}
+function toSnakeCase(str) {
+    if (!str)
+        return '';
+    return str
+        .trim()
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/[\s-]+/g, '_')
+        .toLowerCase();
+}
+function toKebabCase(str) {
+    if (!str)
+        return '';
+    return str
+        .trim()
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function toTitleCase(str) {
+    if (!str)
+        return '';
+    return str
+        .toLowerCase()
+        .split(' ')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2');
+}
+function toSentenceCase(str) {
+    if (!str)
+        return '';
+    if (str.length === 1)
+        return str.toUpperCase();
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function toConstantCase(str) {
+    return toSnakeCase(str).toUpperCase();
+}
+function toDotCase(str) {
+    if (!str)
+        return '';
+    return str
+        .trim()
+        .replace(/([a-z])([A-Z])/g, '$1.$2')
+        .replace(/[\s_-]+/g, '.')
+        .toLowerCase();
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * as OauthTokenService from './oauthTokenService';
+export * from './types';
+export { getOAuthToken } from './oauthTokenService';
+declare const StringUtils: {
+    getOAuthToken: any;
+};
+export default StringUtils;

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOAuthToken = exports.OauthTokenService = void 0;
+// Export all methods grouped by category
+exports.OauthTokenService = __importStar(require("./oauthTokenService"));
+// Export types
+__exportStar(require("./types"), exports);
+// Export individual popular methods for convenience
+var oauthTokenService_1 = require("./oauthTokenService");
+Object.defineProperty(exports, "getOAuthToken", { enumerable: true, get: function () { return oauthTokenService_1.getOAuthToken; } });
+// Default export with all functionality
+const StringUtils = {
+    // Case converters
+    getOAuthToken: require('./oauthTokenService').getOAuthToken,
+};
+exports.default = StringUtils;

package/dist/oauthTokenService/index.d.ts

@@ -0,0 +1 @@
+export declare function getOAuthToken(clientId: string, clientSecret: string, instanceUrl: string): Promise<any>;

package/dist/oauthTokenService/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOAuthToken = getOAuthToken;
+async function getOAuthToken(clientId, clientSecret, instanceUrl) {
+    const url = `https://${instanceUrl}.fs.ocs.oraclecloud.com/rest/oauthTokenService/v2/token`;
+    const credentials = btoa(`${clientId}:${clientSecret}`);
+    const headers = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': `Basic ${credentials}`
+    };
+    const body = new URLSearchParams({
+        'grant_type': 'client_credentials'
+    });
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: headers,
+            body: body
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.access_token;
+    }
+    catch (error) {
+        console.error('Error fetching OAuth token:', error);
+        throw error;
+    }
+}

package/dist/transformers/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * String transformation utilities
+ */
+export declare function reverse(str: string): string;
+export declare function shuffle(str: string): string;
+export declare function slugify(str: string): string;
+export declare function htmlEscape(str: string): string;
+export declare function htmlUnescape(str: string): string;
+export declare function capitalizeWords(str: string): string;
+export declare function replaceAll(str: string, search: string, replacement: string): string;
+export declare function removeWhitespace(str: string): string;
+export declare function normalizeSpaces(str: string): string;
+export declare function toBase64(str: string): string;
+export declare function fromBase64(str: string): string;

package/dist/transformers/index.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * String transformation utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverse = reverse;
+exports.shuffle = shuffle;
+exports.slugify = slugify;
+exports.htmlEscape = htmlEscape;
+exports.htmlUnescape = htmlUnescape;
+exports.capitalizeWords = capitalizeWords;
+exports.replaceAll = replaceAll;
+exports.removeWhitespace = removeWhitespace;
+exports.normalizeSpaces = normalizeSpaces;
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+function reverse(str) {
+    if (!str)
+        return '';
+    return str.split('').reverse().join('');
+}
+function shuffle(str) {
+    if (!str)
+        return '';
+    const array = str.split('');
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array.join('');
+}
+function slugify(str) {
+    if (!str)
+        return '';
+    return str
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function htmlEscape(str) {
+    if (!str)
+        return '';
+    const escapeMap = {
+        '&': '&',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+        '/': '&#x2F;'
+    };
+    return str.replace(/[&<>"'/]/g, char => escapeMap[char]);
+}
+function htmlUnescape(str) {
+    if (!str)
+        return '';
+    const unescapeMap = {
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&quot;': '"',
+        '&#39;': "'",
+        '&#x2F;': '/'
+    };
+    return str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;|&#x2F;/g, entity => unescapeMap[entity]);
+}
+function capitalizeWords(str) {
+    if (!str)
+        return '';
+    return str.replace(/\b\w/g, char => char.toUpperCase());
+}
+function replaceAll(str, search, replacement) {
+    if (!str)
+        return '';
+    return str.split(search).join(replacement);
+}
+function removeWhitespace(str) {
+    if (!str)
+        return '';
+    return str.replace(/\s+/g, '');
+}
+function normalizeSpaces(str) {
+    if (!str)
+        return '';
+    return str.replace(/\s+/g, ' ').trim();
+}
+function toBase64(str) {
+    if (!str)
+        return '';
+    return Buffer.from(str).toString('base64');
+}
+function fromBase64(str) {
+    if (!str)
+        return '';
+    return Buffer.from(str, 'base64').toString('utf8');
+}

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+export interface StringValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+export interface TruncateOptions {
+    ellipsis?: string;
+    preserveWords?: boolean;
+}
+export interface CaseConverter {
+    toCamelCase: (str: string) => string;
+    toPascalCase: (str: string) => string;
+    toSnakeCase: (str: string) => string;
+    toKebabCase: (str: string) => string;
+    toTitleCase: (str: string) => string;
+}
+export interface StringValidator {
+    isEmail: (str: string) => boolean;
+    isURL: (str: string) => boolean;
+    isStrongPassword: (str: string) => StringValidationResult;
+    isPalindrome: (str: string) => boolean;
+    hasSpecialChars: (str: string) => boolean;
+}
+export interface StringTransformer {
+    reverse: (str: string) => string;
+    shuffle: (str: string) => string;
+    slugify: (str: string) => string;
+    htmlEscape: (str: string) => string;
+    htmlUnescape: (str: string) => string;
+}
+export interface StringUtility {
+    truncate: (str: string, maxLength: number, options?: TruncateOptions) => string;
+    countWords: (str: string) => number;
+    countCharacters: (str: string, includeSpaces?: boolean) => number;
+    extractEmails: (str: string) => string[];
+    extractNumbers: (str: string) => number[];
+    generateRandom: (length: number, options?: {
+        includeNumbers?: boolean;
+        includeSpecialChars?: boolean;
+    }) => string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utilities/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/validators/index.d.ts

@@ -0,0 +1,14 @@
+import { StringValidationResult } from '../types';
+/**
+ * String validation utilities
+ */
+export declare function isEmail(str: string): boolean;
+export declare function isURL(str: string): boolean;
+export declare function isStrongPassword(str: string): StringValidationResult;
+export declare function isPalindrome(str: string): boolean;
+export declare function hasSpecialChars(str: string): boolean;
+export declare function isNumeric(str: string): boolean;
+export declare function isAlpha(str: string): boolean;
+export declare function isAlphaNumeric(str: string): boolean;
+export declare function isEmpty(str: string): boolean;
+export declare function isCreditCard(str: string): boolean;

package/dist/validators/index.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmail = isEmail;
+exports.isURL = isURL;
+exports.isStrongPassword = isStrongPassword;
+exports.isPalindrome = isPalindrome;
+exports.hasSpecialChars = hasSpecialChars;
+exports.isNumeric = isNumeric;
+exports.isAlpha = isAlpha;
+exports.isAlphaNumeric = isAlphaNumeric;
+exports.isEmpty = isEmpty;
+exports.isCreditCard = isCreditCard;
+/**
+ * String validation utilities
+ */
+function isEmail(str) {
+    if (!str)
+        return false;
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(str);
+}
+function isURL(str) {
+    if (!str)
+        return false;
+    try {
+        const url = new URL(str);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function isStrongPassword(str) {
+    if (!str) {
+        return {
+            isValid: false,
+            message: 'Password cannot be empty'
+        };
+    }
+    const minLength = 8;
+    const hasUpperCase = /[A-Z]/.test(str);
+    const hasLowerCase = /[a-z]/.test(str);
+    const hasNumbers = /\d/.test(str);
+    const hasSpecialChars = /[!@#$%^&*(),.?":{}|<>]/.test(str);
+    if (str.length < minLength) {
+        return {
+            isValid: false,
+            message: `Password must be at least ${minLength} characters long`
+        };
+    }
+    if (!hasUpperCase) {
+        return {
+            isValid: false,
+            message: 'Password must contain at least one uppercase letter'
+        };
+    }
+    if (!hasLowerCase) {
+        return {
+            isValid: false,
+            message: 'Password must contain at least one lowercase letter'
+        };
+    }
+    if (!hasNumbers) {
+        return {
+            isValid: false,
+            message: 'Password must contain at least one number'
+        };
+    }
+    if (!hasSpecialChars) {
+        return {
+            isValid: false,
+            message: 'Password must contain at least one special character'
+        };
+    }
+    return { isValid: true };
+}
+function isPalindrome(str) {
+    if (!str)
+        return true;
+    const cleanStr = str.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return cleanStr === cleanStr.split('').reverse().join('');
+}
+function hasSpecialChars(str) {
+    if (!str)
+        return false;
+    return /[!@#$%^&*(),.?":{}|<>]/.test(str);
+}
+function isNumeric(str) {
+    if (!str)
+        return false;
+    return /^-?\d*\.?\d+$/.test(str);
+}
+function isAlpha(str) {
+    if (!str)
+        return false;
+    return /^[A-Za-z]+$/.test(str);
+}
+function isAlphaNumeric(str) {
+    if (!str)
+        return false;
+    return /^[A-Za-z0-9]+$/.test(str);
+}
+function isEmpty(str) {
+    return !str || str.trim().length === 0;
+}
+function isCreditCard(str) {
+    if (!str)
+        return false;
+    // Simple Luhn algorithm check
+    const cleanStr = str.replace(/\s+/g, '');
+    if (!/^\d+$/.test(cleanStr))
+        return false;
+    let sum = 0;
+    let isEven = false;
+    for (let i = cleanStr.length - 1; i >= 0; i--) {
+        let digit = parseInt(cleanStr[i], 10);
+        if (isEven) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+        isEven = !isEven;
+    }
+    return sum % 10 === 0;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ofsc-utility",
+  "version": "1.0.0",
+  "description": "A wrapper for Oracle Field Service REST API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "ofs",
+    "oracle",
+    "getOAuthToken"
+  ],
+  "author": "MOHD AHSHAN DANISH <mailtodanish@gmail.com>",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/enhanced-string-utils"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,18 @@
+# Enhanced ofsc utility
+
+A comprehensive TypeScript oracle field service utility library with 40+ methods.
+
+## Features
+
+- 🚀 **40+ utility methods** 
+- 📚 **Written in TypeScript** with full type definitions
+- 🧪 **Completely tested** with Jest
+- 📦 **Zero dependencies**
+- 🎯 **Modular architecture** for tree-shaking
+- 🔧 **Multiple import styles** for flexibility
+
+## Installation
+
+```bash
+npm install ofsc-utility
+```