ofsc-utility 1.0.0 → 1.0.2

package/dist/index.d.ts

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

package/dist/index.js

@@ -45,8 +45,8 @@ __exportStar(require("./types"), exports);
 var oauthTokenService_1 = require("./oauthTokenService");
 Object.defineProperty(exports, "getOAuthToken", { enumerable: true, get: function () { return oauthTokenService_1.getOAuthToken; } });
 // Default export with all functionality
-const StringUtils = {
+const OfscUtility = {
     // Case converters
     getOAuthToken: require('./oauthTokenService').getOAuthToken,
 };
-exports.default = StringUtils;
+exports.default = OfscUtility;

package/dist/oauthTokenService/index.js

@@ -3,7 +3,7 @@ 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 credentials = btoa(`${clientId}@${instanceUrl}:${clientSecret}`);
     const headers = {
         'Content-Type': 'application/x-www-form-urlencoded',
         'Authorization': `Basic ${credentials}`

package/dist/types.d.ts

@@ -2,39 +2,3 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofsc-utility",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A wrapper for Oracle Field Service REST API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,7 +26,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-username/enhanced-string-utils"
+    "url": "https://github.com/mailtodanish/ofsc-utility"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/readme.md

@@ -1,6 +1,6 @@
 # Enhanced ofsc utility
 
-A comprehensive TypeScript oracle field service utility library with 40+ methods.
+A lightweight utility library for interacting with **Oracle Field Service Cloud (OFSC)**.
 
 ## Features
 
@@ -13,6 +13,30 @@ A comprehensive TypeScript oracle field service utility library with 40+ methods
 
 ## Installation
 
-```bash
+``` bash
 npm install ofsc-utility
-```
+```
+
+## Usage
+
+### CommonJS
+
+``` js
+const ofs = require('ofsc-utility');
+
+ofs.getOAuthToken("clientId", "clientSecret", "instanceId")
+  .then((token) => {
+      console.log(token);
+  })
+  .catch((err) => {
+      console.error("Error fetching token:", err);
+  });
+```
+
+## Parameters
+
+  Parameter      Type     Description
+  -------------- -------- ------------------------------
+  clientId       string   OFSC OAuth client ID
+  clientSecret   string   OFSC OAuth client secret
+  instanceId     string   OFSC environment/instance ID

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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,76 +0,0 @@
-"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/transformers/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,97 +0,0 @@
-"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/validators/index.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,126 +0,0 @@
-"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;
-}