@arc-js/id-generator 0.0.0

package/js/index.js

@@ -0,0 +1,422 @@
+const globalFunct = (function (global) {
+    'use strict';
+    class IdentifierGenerator {
+        static instance;
+        cache = new Map();
+        constructor() { }
+        static getInstance() {
+            if (!IdentifierGenerator.instance) {
+                IdentifierGenerator.instance = new IdentifierGenerator();
+            }
+            return IdentifierGenerator.instance;
+        }
+        generate(format, customHandlers = {}) {
+            const tokens = this.parseFormat(format);
+            return tokens.map(token => this.resolveToken(token, customHandlers)).join('');
+        }
+        parseFormat(format) {
+            const tokens = [];
+            let currentIndex = 0;
+            while (currentIndex < format.length) {
+                const nextHashIndex = format.indexOf('#', currentIndex);
+                if (nextHashIndex > currentIndex) {
+                    tokens.push({
+                        type: 'string',
+                        value: format.substring(currentIndex, nextHashIndex)
+                    });
+                    currentIndex = nextHashIndex;
+                }
+                if (format[currentIndex] === '#') {
+                    const tokenEnd = this.findTokenEnd(format, currentIndex + 1);
+                    if (tokenEnd === -1) {
+                        throw new Error(`Format invalide à la position ${currentIndex}`);
+                    }
+                    const tokenContent = format.substring(currentIndex + 1, tokenEnd);
+                    const token = this.parseToken(tokenContent);
+                    tokens.push(token);
+                    currentIndex = tokenEnd;
+                }
+                else if (nextHashIndex === -1) {
+                    tokens.push({
+                        type: 'string',
+                        value: format.substring(currentIndex)
+                    });
+                    break;
+                }
+            }
+            return tokens;
+        }
+        findTokenEnd(format, startIndex) {
+            let braceCount = 0;
+            let inString = false;
+            let escapeNext = false;
+            for (let i = startIndex; i < format.length; i++) {
+                const char = format[i];
+                if (escapeNext) {
+                    escapeNext = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escapeNext = true;
+                    continue;
+                }
+                if (char === '"' || char === "'") {
+                    inString = !inString;
+                    continue;
+                }
+                if (!inString) {
+                    if (char === '{') {
+                        braceCount++;
+                    }
+                    else if (char === '}') {
+                        if (braceCount === 0) {
+                            return i;
+                        }
+                        braceCount--;
+                    }
+                    else if (char === '#' && braceCount === 0) {
+                        return i;
+                    }
+                    else if (/[a-zA-Z0-9]/.test(char) === false && char !== ',' && char !== ':' && char !== '-' && char !== '_' && braceCount === 0) {
+                        return i;
+                    }
+                }
+            }
+            return format.length;
+        }
+        /**
+         * Parse un token individuel
+         */
+        parseToken(tokenContent) {
+            // Token personnalisé simple
+            if (tokenContent.includes('{') === false) {
+                return { type: 'string', value: tokenContent };
+            }
+            const [type, optionsStr] = tokenContent.split('{', 2);
+            const optionsContent = optionsStr.slice(0, -1); // Retirer le '}'
+            if (type === 'rand') {
+                return {
+                    type: 'random',
+                    value: this.parseRandomOptions(optionsContent)
+                };
+            }
+            else if (type === 'uuid') {
+                return {
+                    type: 'uuid',
+                    value: this.parseUUIDOptions(optionsContent)
+                };
+            }
+            else if (type === 'custom') {
+                return {
+                    type: 'custom',
+                    value: optionsContent
+                };
+            }
+            throw new Error(`Type de token non supporté: ${type}`);
+        }
+        /**
+         * Parse les options pour un random string
+         */
+        parseRandomOptions(optionsStr) {
+            const defaults = {
+                size: 8,
+                type: 'alphanumeric',
+                variant: false
+            };
+            const options = this.parseOptions(optionsStr);
+            return {
+                size: options.size ? parseInt(options.size) : defaults.size,
+                type: options.type || defaults.type,
+                variant: options.variant === 'true' ? true : defaults.variant
+            };
+        }
+        /**
+         * Parse les options pour un UUID
+         */
+        parseUUIDOptions(optionsStr) {
+            const defaults = {
+                version: 'v4'
+            };
+            const options = this.parseOptions(optionsStr);
+            return {
+                version: options.version || defaults.version
+            };
+        }
+        /**
+         * Parse une chaîne d'options key:value
+         */
+        parseOptions(optionsStr) {
+            const options = {};
+            let currentKey = '';
+            let currentValue = '';
+            let inString = false;
+            let stringChar = '';
+            let braceCount = 0;
+            for (let i = 0; i < optionsStr.length; i++) {
+                const char = optionsStr[i];
+                if (char === '"' || char === "'") {
+                    if (!inString) {
+                        inString = true;
+                        stringChar = char;
+                    }
+                    else if (stringChar === char) {
+                        inString = false;
+                    }
+                    else {
+                        currentValue += char;
+                    }
+                    continue;
+                }
+                if (inString) {
+                    currentValue += char;
+                    continue;
+                }
+                if (char === ':') {
+                    if (braceCount === 0) {
+                        currentKey = currentValue.trim();
+                        currentValue = '';
+                        continue;
+                    }
+                }
+                else if (char === '{') {
+                    braceCount++;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                }
+                else if (char === ',' && braceCount === 0) {
+                    options[currentKey] = currentValue.trim();
+                    currentKey = '';
+                    currentValue = '';
+                    continue;
+                }
+                currentValue += char;
+            }
+            if (currentKey) {
+                options[currentKey] = currentValue.trim();
+            }
+            return options;
+        }
+        resolveToken(token, customHandlers) {
+            switch (token.type) {
+                case 'string':
+                    return token.value;
+                case 'random':
+                    return this.generateRandomString(token.value);
+                case 'uuid':
+                    return this.generateUUID(token.value);
+                case 'custom':
+                    const handlerName = token.value.split('}').join('').split('{').join('');
+                    const checker = Object.keys(customHandlers).includes(handlerName);
+                    if (checker) {
+                        return customHandlers[handlerName]();
+                    }
+                    else {
+                        console.log(`[id-generator -> id-generator] IdentifierGenerator | resolveToken - custom - token:: `, token);
+                        console.log(`[id-generator -> id-generator] IdentifierGenerator | resolveToken - custom - handlerName:: `, handlerName);
+                        console.log(`[id-generator -> id-generator] IdentifierGenerator | resolveToken - custom - checker:: `, checker);
+                        console.log(`[id-generator -> id-generator] IdentifierGenerator | resolveToken - custom - Object.keys(customHandlers):: `, Object.keys(customHandlers));
+                        console.log(`[id-generator -> id-generator] IdentifierGenerator | resolveToken - custom - customHandlers:: `, customHandlers);
+                        throw new Error(`Handler personnalisé non trouvé: ${handlerName}`);
+                    }
+                default:
+                    throw new Error(`Type de token inconnu: ${token.type}`);
+            }
+        }
+        generateRandomString(options) {
+            const cacheKey = this.getRandomCacheKey(options);
+            if (!options.variant) {
+                if (!this.cache.has('random')) {
+                    this.cache.set('random', new Map());
+                }
+                const randomCache = this.cache.get('random');
+                if (randomCache.has(cacheKey)) {
+                    return randomCache.get(cacheKey);
+                }
+            }
+            let charset = '';
+            let result = '';
+            switch (options.type) {
+                case 'numeric':
+                    charset = '0123456789';
+                    break;
+                case 'alphabetic':
+                    charset = 'abcdefghijklmnopqrstuvwxyz';
+                    break;
+                case 'alphabetic-case':
+                    charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+                    break;
+                case 'alphanumeric':
+                    charset = 'abcdefghijklmnopqrstuvwxyz0123456789';
+                    break;
+                case 'alphanumeric-case':
+                    charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+                    break;
+            }
+            const randomValues = new Uint32Array(options.size);
+            crypto.getRandomValues(randomValues);
+            for (let i = 0; i < options.size; i++) {
+                result += charset[randomValues[i] % charset.length];
+            }
+            if (!options.variant) {
+                this.cache.get('random').set(cacheKey, result);
+            }
+            return result;
+        }
+        generateUUID(options) {
+            const cacheKey = `uuid-${options.version}`;
+            if (!this.cache.has('uuid')) {
+                this.cache.set('uuid', new Map());
+            }
+            const uuidCache = this.cache.get('uuid');
+            if (uuidCache.has(cacheKey)) {
+                if (options.version === 'v4') {
+                    return this.generateUUIDv4();
+                }
+                return uuidCache.get(cacheKey);
+            }
+            let uuid;
+            switch (options.version) {
+                case 'v1':
+                    uuid = this.generateUUIDv1();
+                    break;
+                case 'v2':
+                    uuid = this.generateUUIDv2();
+                    break;
+                case 'v3':
+                    uuid = this.generateUUIDv3();
+                    break;
+                case 'v4':
+                    uuid = this.generateUUIDv4();
+                    break;
+                case 'v5':
+                    uuid = this.generateUUIDv5();
+                    break;
+                default:
+                    uuid = this.generateUUIDv4();
+            }
+            if (options.version === 'v3' || options.version === 'v5') {
+                uuidCache.set(cacheKey, uuid);
+            }
+            return uuid;
+        }
+        generateUUIDv1() {
+            const now = Date.now();
+            const hexTime = now.toString(16).padStart(12, '0');
+            return `${hexTime.slice(0, 8)}-${hexTime.slice(8, 12)}-1000-8000-${this.getRandomHex(12)}`;
+        }
+        generateUUIDv2() {
+            return this.generateUUIDv1();
+        }
+        generateUUIDv3() {
+            const namespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+            const name = 'default';
+            return 'xxxxxxxx-xxxx-3xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+                const r = Math.random() * 16 | 0;
+                const v = c === 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+        generateUUIDv4() {
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+                const r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0;
+                const v = c === 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+        generateUUIDv5() {
+            const namespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+            const name = 'default';
+            return 'xxxxxxxx-xxxx-5xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+                const r = Math.random() * 16 | 0;
+                const v = c === 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+        getRandomHex(size) {
+            const bytes = new Uint8Array(Math.ceil(size / 2));
+            crypto.getRandomValues(bytes);
+            return Array.from(bytes)
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('')
+                .slice(0, size);
+        }
+        getRandomCacheKey(options) {
+            return `${options.size}-${options.type}-${options.variant}`;
+        }
+        clearCache() {
+            this.cache.clear();
+        }
+        static generateId(format, customHandlers = {}) {
+            return this.getInstance().generate(format, customHandlers);
+        }
+        static exposeToGlobal() {
+            if (typeof window !== 'undefined') {
+                window.IdentifierGenerator = IdentifierGenerator;
+                window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+            }
+        }
+    }
+    const IdentifierGeneratorHandlers = {
+        timestamp: () => Date.now().toString(),
+        date: () => new Date().toISOString().slice(0, 10).replace(/-/g, ''),
+        time: () => new Date().toISOString().slice(11, 19).replace(/:/g, ''),
+        counter: (() => {
+            let count = 0;
+            return () => (++count).toString().padStart(6, '0');
+        })(),
+        env: (envVar) => process.env[envVar] || ''
+    };
+    if (typeof window !== 'undefined') {
+        window.IdentifierGenerator = IdentifierGenerator;
+        window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+    export default {
+        IdentifierGenerator,
+        IdentifierGeneratorHandlers,
+    };
+    const globalFunctModule = {
+        default: {},
+        IdentifierGenerator: IdentifierGenerator,
+        IdentifierGeneratorHandlers: IdentifierGeneratorHandlers,
+    };
+    globalFunctModule.default = { ...(globalFunctModule?.default || {}), IdentifierGenerator: IdentifierGenerator };
+    globalFunctModule.default = { ...(globalFunctModule?.default || {}), IdentifierGeneratorHandlers: IdentifierGeneratorHandlers };
+    const __bundledModules = globalFunctModule;
+    if (typeof global !== 'undefined') {
+        global.IdentifierGenerator = IdentifierGenerator;
+        global.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        global.__bundledModules = __bundledModules;
+    }
+    if (typeof window !== "undefined") {
+        window.IdentifierGenerator = IdentifierGenerator;
+        window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        window.__bundledModules = __bundledModules;
+    }
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = __bundledModules;
+        module.exports.IdentifierGenerator = IdentifierGenerator;
+        module.exports.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+    if (typeof exports !== 'undefined') {
+        exports.IdentifierGenerator = IdentifierGenerator;
+        exports.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+    return __bundledModules;
+})(typeof global !== 'undefined' ? global :
+    typeof window !== 'undefined' ? window :
+        typeof self !== 'undefined' ? self :
+            typeof globalThis !== 'undefined' ? globalThis :
+                {});
+const IdentifierGeneratorElementGF = globalFunct.IdentifierGenerator;
+const IdentifierGeneratorHandlersElementGF = globalFunct.IdentifierGeneratorHandlers;
+export { IdentifierGeneratorElementGF as IdentifierGenerator, IdentifierGeneratorHandlersElementGF as IdentifierGeneratorHandlers, };
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        IdentifierGenerator: IdentifierGeneratorElementGF,
+        IdentifierGeneratorHandlers: IdentifierGeneratorHandlersElementGF,
+    };
+}
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports.default = globalFunct?.default;
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/id-generator",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "description": "ID-GENERATOR est une bibliothèque TypeScript robuste pour générer des identifiants uniques avec des formats personnalisables. Elle offre une syntaxe expressive pour créer des identifiants complexes combinant texte, chaînes aléatoires, UUID et fonctions personnalisées.",
+  "main": "index.js",
+  "keywords": [],
+  "author": "INICODE <contact.inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@arc-js/id-generator",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {}
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false,
+        
+        "strict": false,
+        "noImplicitAny": false,
+        "strictNullChecks": false,
+        "strictFunctionTypes": false,
+        "strictBindCallApply": false,
+        "strictPropertyInitialization": false,
+        "noImplicitThis": false,
+        "alwaysStrict": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}