@jsarc/id-generator 0.0.0 → 0.0.1-beta.0.1

package/id-generator.ts

@@ -0,0 +1,538 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    IdentifierGenerator: any;
+    IdentifierGeneratorHandlers: any;
+    __bundledModules: any;
+}
+
+interface RandomOptions {
+    size: number;
+    type: RandomType;
+    variant: boolean;
+}
+
+
+interface UUIDOptions {
+    version: UUIDVersion;
+}
+
+
+interface TokenDefinition {
+    type: 'string' | 'random' | 'uuid' | 'custom';
+    value: string | RandomOptions | UUIDOptions | CustomHandler;
+}
+
+
+
+
+
+
+
+
+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 as any).IdentifierGenerator = IdentifierGenerator;
+                (window as any).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 as any).IdentifierGenerator = IdentifierGenerator;
+        (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+
+    const idGen = {
+        IdentifierGenerator,
+        IdentifierGeneratorHandlers,
+    };
+
+    
+    const globalFunctModule = {
+        default: idGen,
+        IdentifierGenerator: IdentifierGenerator,
+        IdentifierGeneratorHandlers: IdentifierGeneratorHandlers,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = idGen;
+        (global as any).IdentifierGenerator = IdentifierGenerator;
+        (global as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = idGen;
+        (window as any).IdentifierGenerator = IdentifierGenerator;
+        (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = idGen;
+        exports.IdentifierGenerator = IdentifierGenerator;
+        exports.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+    }
+	return globalFunctModule;
+
+})(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;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const IdentifierGeneratorElementGF: IdentifierGeneratorElementTypeGF = globalFunct.IdentifierGenerator;
+
+const IdentifierGeneratorHandlersElementGF: IdentifierGeneratorHandlersElementTypeGF = globalFunct.IdentifierGeneratorHandlers;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+
+

package/index.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 
 interface Window {
+    default: typeof defaultElementGF;
     IdentifierGenerator: any;
     IdentifierGeneratorHandlers: any;
     __bundledModules: any;
@@ -463,8 +464,8 @@ const globalFunct = (function(global: any) {
 
         static exposeToGlobal(): void {
             if (typeof window !== 'undefined') {
-                window.IdentifierGenerator = IdentifierGenerator;
-                window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+                (window as any).IdentifierGenerator = IdentifierGenerator;
+                (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
             }
         }
     }
@@ -481,17 +482,18 @@ const globalFunct = (function(global: any) {
     };
 
     if (typeof window !== 'undefined') {
-        window.IdentifierGenerator = IdentifierGenerator;
-        window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
+        (window as any).IdentifierGenerator = IdentifierGenerator;
+        (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
     }
 
-    export default {
+    const idGen = {
         IdentifierGenerator,
         IdentifierGeneratorHandlers,
-    }
+    };
+
     
     const globalFunctModule = {
-        default: ({} as any),
+        default: idGen,
         IdentifierGenerator: IdentifierGenerator,
         IdentifierGeneratorHandlers: IdentifierGeneratorHandlers,
     };
@@ -500,18 +502,21 @@ const globalFunct = (function(global: any) {
     const __bundledModules = globalFunctModule;
     
     if (typeof global !== 'undefined') {
+        (global as any).default = idGen;
         (global as any).IdentifierGenerator = IdentifierGenerator;
         (global as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
         (global as any).__bundledModules = __bundledModules;
     }
     
     if (typeof window !== "undefined") {
+        (window as any).default = idGen;
         (window as any).IdentifierGenerator = IdentifierGenerator;
         (window as any).IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
         (window as any).__bundledModules = __bundledModules;
     }
     
     if (typeof exports !== 'undefined') {
+        exports.default = idGen;
         exports.IdentifierGenerator = IdentifierGenerator;
         exports.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
     }
@@ -527,13 +532,21 @@ type IdentifierGeneratorElementTypeGF = typeof globalFunct.IdentifierGenerator;
 
 type IdentifierGeneratorHandlersElementTypeGF = typeof globalFunct.IdentifierGeneratorHandlers;
 
+type DefaultElementTypeGF = typeof globalFunct.default;
+
 const IdentifierGeneratorElementGF: IdentifierGeneratorElementTypeGF = globalFunct.IdentifierGenerator;
 
 const IdentifierGeneratorHandlersElementGF: IdentifierGeneratorHandlersElementTypeGF = globalFunct.IdentifierGeneratorHandlers;
 
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
 export {
+	defaultElementGF as default,
 	IdentifierGeneratorElementGF as IdentifierGenerator,
 	IdentifierGeneratorHandlersElementGF as IdentifierGeneratorHandlers,
 };
 export type {
+	DefaultElementTypeGF,
+	RandomType,UUIDVersion,CustomHandler,RandomOptions,UUIDOptions,TokenDefinition,
+	IdentifierGeneratorElementTypeGF,IdentifierGeneratorHandlersElementTypeGF,
 };

package/js/index.js

@@ -371,27 +371,30 @@ const globalFunct = (function (global) {
         window.IdentifierGenerator = IdentifierGenerator;
         window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
     }
-    export default {
+    const idGen = {
         IdentifierGenerator,
         IdentifierGeneratorHandlers,
     };
     const globalFunctModule = {
-        default: {},
+        default: idGen,
         IdentifierGenerator: IdentifierGenerator,
         IdentifierGeneratorHandlers: IdentifierGeneratorHandlers,
     };
     const __bundledModules = globalFunctModule;
     if (typeof global !== 'undefined') {
+        global.default = idGen;
         global.IdentifierGenerator = IdentifierGenerator;
         global.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
         global.__bundledModules = __bundledModules;
     }
     if (typeof window !== "undefined") {
+        window.default = idGen;
         window.IdentifierGenerator = IdentifierGenerator;
         window.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
         window.__bundledModules = __bundledModules;
     }
     if (typeof exports !== 'undefined') {
+        exports.default = idGen;
         exports.IdentifierGenerator = IdentifierGenerator;
         exports.IdentifierGeneratorHandlers = IdentifierGeneratorHandlers;
     }
@@ -403,4 +406,5 @@ const globalFunct = (function (global) {
                 {});
 const IdentifierGeneratorElementGF = globalFunct.IdentifierGenerator;
 const IdentifierGeneratorHandlersElementGF = globalFunct.IdentifierGeneratorHandlers;
-export { IdentifierGeneratorElementGF as IdentifierGenerator, IdentifierGeneratorHandlersElementGF as IdentifierGeneratorHandlers, };
+const defaultElementGF = globalFunct.default;
+export { defaultElementGF as default, IdentifierGeneratorElementGF as IdentifierGenerator, IdentifierGeneratorHandlersElementGF as IdentifierGeneratorHandlers, };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0",
+  "version": "0.0.1-beta.0.1",
   "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.ts",
   "keywords": [],