@arc-js/id-generator 0.0.0

package/index.ts

@@ -0,0 +1,560 @@
+// @ts-nocheck
+
+interface Window {
+    IdentifierGenerator: any;
+    IdentifierGeneratorHandlers: any;
+    __bundledModules: any;
+}
+
+export interface RandomOptions {
+    size: number;
+    type: RandomType;
+    variant: boolean;
+}
+
+
+export interface UUIDOptions {
+    version: UUIDVersion;
+}
+
+
+export interface TokenDefinition {
+    type: 'string' | 'random' | 'uuid' | 'custom';
+    value: string | RandomOptions | UUIDOptions | CustomHandler;
+}
+
+
+export type RandomType = (
+    'numeric'
+    | 'alphabetic'
+    | 'alphabetic-case'
+    | 'alphanumeric'
+    | 'alphanumeric-case'
+);
+
+export type UUIDVersion = 'v1' | 'v2' | 'v3' | 'v4' | 'v5';
+
+export type CustomHandler = () => string;
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+
+
+
+
+
+
+
+
+
+    class IdentifierGenerator {
+        private static instance: IdentifierGenerator;
+        private cache: Map<string, Map<string, string>> = new Map();
+
+        private constructor() { }
+
+        public static getInstance(): IdentifierGenerator {
+            if (!IdentifierGenerator.instance) {
+                IdentifierGenerator.instance = new IdentifierGenerator();
+            }
+            return IdentifierGenerator.instance;
+        }
+
+        public generate(format: string, customHandlers: Record<string, CustomHandler> = {}): string {
+            const tokens = this.parseFormat(format);
+            return tokens.map(token => this.resolveToken(token, customHandlers)).join('');
+        }
+
+        private parseFormat(format: string): TokenDefinition[] {
+            const tokens: TokenDefinition[] = [];
+            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;
+        }
+
+        private findTokenEnd(format: string, startIndex: number): number {
+            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
+         */
+        private parseToken(tokenContent: string): TokenDefinition {
+            // 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
+         */
+        private parseRandomOptions(optionsStr: string): RandomOptions {
+            const defaults: RandomOptions = {
+                size: 8,
+                type: 'alphanumeric',
+                variant: false
+            };
+
+            const options = this.parseOptions(optionsStr);
+
+            return {
+                size: options.size ? parseInt(options.size) : defaults.size,
+                type: (options.type as RandomType) || defaults.type,
+                variant: options.variant === 'true' ? true : defaults.variant
+            };
+        }
+
+        /**
+         * Parse les options pour un UUID
+         */
+        private parseUUIDOptions(optionsStr: string): UUIDOptions {
+            const defaults: UUIDOptions = {
+                version: 'v4'
+            };
+
+            const options = this.parseOptions(optionsStr);
+
+            return {
+                version: (options.version as UUIDVersion) || defaults.version
+            };
+        }
+
+        /**
+         * Parse une chaîne d'options key:value
+         */
+        private parseOptions(optionsStr: string): Record<string, string> {
+            const options: Record<string, string> = {};
+            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;
+        }
+
+        private resolveToken(token: TokenDefinition, customHandlers: Record<string, CustomHandler>): string {
+            switch (token.type) {
+                case 'string':
+                    return token.value as string;
+
+                case 'random':
+                    return this.generateRandomString(token.value as RandomOptions);
+
+                case 'uuid':
+                    return this.generateUUID(token.value as UUIDOptions);
+
+                case 'custom':
+                    const handlerName = (token.value as string).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}`);
+            }
+        }
+
+        private generateRandomString(options: RandomOptions): string {
+            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;
+        }
+
+        private generateUUID(options: UUIDOptions): string {
+            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: string;
+
+            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;
+        }
+
+        private generateUUIDv1(): string {
+
+            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)}`;
+        }
+
+        private generateUUIDv2(): string {
+
+            return this.generateUUIDv1();
+        }
+
+        private generateUUIDv3(): string {
+
+            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);
+            });
+        }
+
+        private generateUUIDv4(): string {
+
+            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);
+            });
+        }
+
+        private generateUUIDv5(): string {
+
+            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);
+            });
+        }
+
+        private getRandomHex(size: number): string {
+            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);
+        }
+
+        private getRandomCacheKey(options: RandomOptions): string {
+            return `${options.size}-${options.type}-${options.variant}`;
+        }
+
+        public clearCache(): void {
+            this.cache.clear();
+        }
+
+        public static generateId(format: string, customHandlers: Record<string, CustomHandler> = {}): string {
+            return this.getInstance().generate(format, customHandlers);
+        }
+
+        static exposeToGlobal(): void {
+            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: string) => process.env[envVar] || ''
+    };
+
+    if (typeof window !== 'undefined') {
+        window.IdentifierGenerator = IdentifierGenerator;
+        window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+
+    export default {
+        IdentifierGenerator,
+        IdentifierGeneratorHandlers,
+    }
+    
+    const globalFunctModule = {
+        default: ({} as any),
+        IdentifierGenerator: IdentifierGenerator,
+        IdentifierGeneratorHandlers: IdentifierGeneratorHandlers,
+    };
+    
+    globalFunctModule.default = {...(globalFunctModule?.default || {}), IdentifierGenerator: IdentifierGenerator};
+    globalFunctModule.default = {...(globalFunctModule?.default || {}), IdentifierGeneratorHandlers: IdentifierGeneratorHandlers};
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).IdentifierGenerator = IdentifierGenerator;
+        (global as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).IdentifierGenerator = IdentifierGenerator;
+        (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        (window as any).__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 : 
+   {});
+
+type IdentifierGeneratorElementTypeGF = typeof globalFunct.IdentifierGenerator;
+
+type IdentifierGeneratorHandlersElementTypeGF = typeof globalFunct.IdentifierGeneratorHandlers;
+
+const IdentifierGeneratorElementGF: IdentifierGeneratorElementTypeGF = globalFunct.IdentifierGenerator;
+
+const IdentifierGeneratorHandlersElementGF: IdentifierGeneratorHandlersElementTypeGF = 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;
+}
+
+// Types exportés
+export type { RandomType, UUIDVersion, CustomHandler, RandomOptions, UUIDOptions, TokenDefinition };
+
+export type { IdentifierGeneratorElementTypeGF, IdentifierGeneratorHandlersElementTypeGF };