@arc-js/id-generator 0.0.1

package/id-generator.all.js

@@ -0,0 +1,447 @@
+class IdentifierGenerator {
+    static instance;
+    cache = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!IdentifierGenerator.instance) {
+            IdentifierGenerator.instance = new IdentifierGenerator();
+        }
+        return IdentifierGenerator.instance;
+    }
+    /**
+     * Parse un format d'identifiant et génère l'identifiant
+     */
+    generate(format, customHandlers = {}) {
+        const tokens = this.parseFormat(format);
+        return tokens.map(token => this.resolveToken(token, customHandlers)).join('');
+    }
+    /**
+     * Parse le format en tokens
+     */
+    parseFormat(format) {
+        const tokens = [];
+        let currentIndex = 0;
+        while (currentIndex < format.length) {
+            const nextHashIndex = format.indexOf('#', currentIndex);
+            // Texte littéral avant le prochain token
+            if (nextHashIndex > currentIndex) {
+                tokens.push({
+                    type: 'string',
+                    value: format.substring(currentIndex, nextHashIndex)
+                });
+                currentIndex = nextHashIndex;
+            }
+            // Token spécial
+            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) {
+                // Reste du texte
+                tokens.push({
+                    type: 'string',
+                    value: format.substring(currentIndex)
+                });
+                break;
+            }
+        }
+        return tokens;
+    }
+    /**
+     * Trouve la fin d'un token
+     */
+    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;
+    }
+    /**
+     * Résout un token en sa valeur
+     */
+    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}`);
+        }
+    }
+    /**
+     * Génère une chaîne aléatoire
+     */
+    generateRandomString(options) {
+        const cacheKey = this.getRandomCacheKey(options);
+        // Si non variant, on utilise le cache
+        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;
+        }
+        // Utilisation de crypto.getRandomValues pour une meilleure sécurité/performance
+        const randomValues = new Uint32Array(options.size);
+        crypto.getRandomValues(randomValues);
+        for (let i = 0; i < options.size; i++) {
+            result += charset[randomValues[i] % charset.length];
+        }
+        // Mise en cache si non variant
+        if (!options.variant) {
+            this.cache.get('random').set(cacheKey, result);
+        }
+        return result;
+    }
+    /**
+     * Génère un UUID selon la version spécifiée
+     */
+    generateUUID(options) {
+        const cacheKey = `uuid-${options.version}`;
+        if (!this.cache.has('uuid')) {
+            this.cache.set('uuid', new Map());
+        }
+        const uuidCache = this.cache.get('uuid');
+        // Les UUID sont par définition variants, mais on peut optimiser la génération
+        if (uuidCache.has(cacheKey)) {
+            // Pour v4, on ne cache pas car variant
+            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();
+        }
+        // On ne cache que les UUID non-variants (v3 et v5 sont basés sur des noms)
+        if (options.version === 'v3' || options.version === 'v5') {
+            uuidCache.set(cacheKey, uuid);
+        }
+        return uuid;
+    }
+    generateUUIDv1() {
+        // Implémentation simplifiée de UUID v1
+        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() {
+        // Version 2 rarement utilisée, implémentation de base
+        return this.generateUUIDv1();
+    }
+    generateUUIDv3() {
+        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() {
+        // UUID v4 standard (aléatoire)
+        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() {
+        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}`;
+    }
+    /**
+     * Vide le cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Méthode utilitaire pour générer un identifiant unique
+     */
+    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;
+}
+var index_all = {
+    IdentifierGenerator,
+    IdentifierGeneratorHandlers,
+};
+// Exemple d'utilisation
+/*
+import { IdentifierGenerator, IdentifierGeneratorHandlers } from './identifier';
+
+const generator = IdentifierGenerator.getInstance();
+
+// Exemple 1
+const id1 = generator.generate(
+  'mda#rand{size:10,type:alphanumeric}-#uuid{version:v1}',
+  {
+    customTimestamp: () => Date.now().toString()
+  }
+);
+
+// Exemple 2
+const id2 = generator.generate(
+  'lorem#rand{type:alphanumeric, variant:true}ipsum',
+  {
+    user: () => 'john_doe'
+  }
+);
+
+// Exemple 3 avec handler personnalisé
+const id3 = generator.generate(
+  'user-#custom{userId}-#rand{size:6,type:numeric}',
+  {
+    userId: () => 'USR_' + Math.random().toString(36).substr(2, 9)
+  }
+);
+
+// Utilisation de la méthode statique
+const id4 = IdentifierGenerator.generateId(
+  'order-#custom{timestamp}-#rand{size:8,type:alphanumeric-case}',
+  {
+    timestamp: IdentifierGeneratorHandlers.timestamp
+  }
+);
+*/
+
+

package/id-generator.all.min.js

@@ -0,0 +1 @@
+class IdentifierGenerator{static instance;cache=new Map;constructor(){}static getInstance(){return IdentifierGenerator.instance||(IdentifierGenerator.instance=new IdentifierGenerator),IdentifierGenerator.instance}generate(e,r={}){return this.parseFormat(e).map(e=>this.resolveToken(e,r)).join("")}parseFormat(e){var r=[];let t=0;for(;t<e.length;){var n=e.indexOf("#",t);if(n>t&&(r.push({type:"string",value:e.substring(t,n)}),t=n),"#"===e[t]){var a=this.findTokenEnd(e,t+1);if(-1===a)throw new Error("Format invalide à la position "+t);var i=e.substring(t+1,a),i=this.parseToken(i);r.push(i),t=a}else if(-1===n){r.push({type:"string",value:e.substring(t)});break}}return r}findTokenEnd(r,t){let n=0,a=!1,i=!1;for(let e=t;e<r.length;e++){var s=r[e];if(i)i=!1;else if("\\"===s)i=!0;else if('"'===s||"'"===s)a=!a;else if(!a)if("{"===s)n++;else if("}"===s){if(0===n)return e;n--}else{if("#"===s&&0===n)return e;if(!1===/[a-zA-Z0-9]/.test(s)&&","!==s&&":"!==s&&"-"!==s&&"_"!==s&&0===n)return e}}return r.length}parseToken(e){if(!1===e.includes("{"))return{type:"string",value:e};var[e,r]=e.split("{",2),r=r.slice(0,-1);if("rand"===e)return{type:"random",value:this.parseRandomOptions(r)};if("uuid"===e)return{type:"uuid",value:this.parseUUIDOptions(r)};if("custom"===e)return{type:"custom",value:r};throw new Error("Type de token non supporté: "+e)}parseRandomOptions(e){const r=8,t="alphanumeric",n=!1;e=this.parseOptions(e);return{size:e.size?parseInt(e.size):r,type:e.type||t,variant:"true"===e.variant||n}}parseUUIDOptions(e){return{version:this.parseOptions(e).version||"v4"}}parseOptions(r){var t={};let n="",a="",i=!1,s="",o=0;for(let e=0;e<r.length;e++){var x=r[e];if('"'===x||"'"===x)i?s===x?i=!1:a+=x:(i=!0,s=x);else{if(!i)if(":"===x){if(0===o){n=a.trim(),a="";continue}}else if("{"===x)o++;else if("}"===x)o--;else if(","===x&&0===o){t[n]=a.trim(),n="",a="";continue}a+=x}}return n&&(t[n]=a.trim()),t}resolveToken(e,r){switch(e.type){case"string":return e.value;case"random":return this.generateRandomString(e.value);case"uuid":return this.generateUUID(e.value);case"custom":var t=e.value.split("}").join("").split("{").join(""),n=Object.keys(r).includes(t);if(n)return r[t]();throw new Error("Handler personnalisé non trouvé: "+t);default:throw new Error("Type de token inconnu: "+e.type)}}generateRandomString(r){var e=this.getRandomCacheKey(r);if(!r.variant){this.cache.has("random")||this.cache.set("random",new Map);var t=this.cache.get("random");if(t.has(e))return t.get(e)}let n="",a="";switch(r.type){case"numeric":n="0123456789";break;case"alphabetic":n="abcdefghijklmnopqrstuvwxyz";break;case"alphabetic-case":n="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";break;case"alphanumeric":n="abcdefghijklmnopqrstuvwxyz0123456789";break;case"alphanumeric-case":n="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"}var i=new Uint32Array(r.size);crypto.getRandomValues(i);for(let e=0;e<r.size;e++)a+=n[i[e]%n.length];return r.variant||this.cache.get("random").set(e,a),a}generateUUID(e){var r="uuid-"+e.version,t=(this.cache.has("uuid")||this.cache.set("uuid",new Map),this.cache.get("uuid"));if(t.has(r))return"v4"===e.version?this.generateUUIDv4():t.get(r);let n;switch(e.version){case"v1":n=this.generateUUIDv1();break;case"v2":n=this.generateUUIDv2();break;case"v3":n=this.generateUUIDv3();break;case"v4":n=this.generateUUIDv4();break;case"v5":n=this.generateUUIDv5();break;default:n=this.generateUUIDv4()}return"v3"!==e.version&&"v5"!==e.version||t.set(r,n),n}generateUUIDv1(){var e=Date.now().toString(16).padStart(12,"0");return`${e.slice(0,8)}-${e.slice(8,12)}-1000-8000-`+this.getRandomHex(12)}generateUUIDv2(){return this.generateUUIDv1()}generateUUIDv3(){return"xxxxxxxx-xxxx-3xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{var r=16*Math.random()|0;return("x"===e?r:3&r|8).toString(16)})}generateUUIDv4(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{var r=crypto.getRandomValues(new Uint8Array(1))[0]%16|0;return("x"===e?r:3&r|8).toString(16)})}generateUUIDv5(){return"xxxxxxxx-xxxx-5xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{var r=16*Math.random()|0;return("x"===e?r:3&r|8).toString(16)})}getRandomHex(e){var r=new Uint8Array(Math.ceil(e/2));return crypto.getRandomValues(r),Array.from(r).map(e=>e.toString(16).padStart(2,"0")).join("").slice(0,e)}getRandomCacheKey(e){return e.size+`-${e.type}-`+e.variant}clearCache(){this.cache.clear()}static generateId(e,r={}){return this.getInstance().generate(e,r)}static exposeToGlobal(){"undefined"!=typeof window&&(window.IdentifierGenerator=IdentifierGenerator,window.IdentifierGeneratorHandlers=IdentifierGeneratorHandlers)}}let 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 e=0;return()=>(++e).toString().padStart(6,"0")})(),env:e=>process.env[e]||""};"undefined"!=typeof window&&(window.IdentifierGenerator=IdentifierGenerator,window.IdentifierGeneratorHandlers=IdentifierGeneratorHandlers);var index_all={IdentifierGenerator:IdentifierGenerator,IdentifierGeneratorHandlers:IdentifierGeneratorHandlers};

package/index.d.ts

@@ -0,0 +1,103 @@
+type RandomType = 'numeric' | 'alphabetic' | 'alphabetic-case' | 'alphanumeric' | 'alphanumeric-case';
+type UUIDVersion = 'v1' | 'v2' | 'v3' | 'v4' | 'v5';
+interface RandomOptions {
+    size: number;
+    type: RandomType;
+    variant: boolean;
+}
+interface UUIDOptions {
+    version: UUIDVersion;
+}
+interface TokenDefinition {
+    type: 'string' | 'random' | 'uuid' | 'custom';
+    value: string | RandomOptions | UUIDOptions | CustomHandler;
+}
+type CustomHandler = () => string;
+declare global {
+    interface Window {
+        IdentifierGenerator: typeof IdentifierGenerator;
+        IdentifierGeneratorHandlers: any;
+    }
+}
+declare class IdentifierGenerator {
+    private static instance;
+    private cache;
+    private constructor();
+    static getInstance(): IdentifierGenerator;
+    /**
+     * Parse un format d'identifiant et génère l'identifiant
+     */
+    generate(format: string, customHandlers?: Record<string, CustomHandler>): string;
+    /**
+     * Parse le format en tokens
+     */
+    private parseFormat;
+    /**
+     * Trouve la fin d'un token
+     */
+    private findTokenEnd;
+    /**
+     * Parse un token individuel
+     */
+    private parseToken;
+    /**
+     * Parse les options pour un random string
+     */
+    private parseRandomOptions;
+    /**
+     * Parse les options pour un UUID
+     */
+    private parseUUIDOptions;
+    /**
+     * Parse une chaîne d'options key:value
+     */
+    private parseOptions;
+    /**
+     * Résout un token en sa valeur
+     */
+    private resolveToken;
+    /**
+     * Génère une chaîne aléatoire
+     */
+    private generateRandomString;
+    /**
+     * Génère un UUID selon la version spécifiée
+     */
+    private generateUUID;
+    private generateUUIDv1;
+    private generateUUIDv2;
+    private generateUUIDv3;
+    private generateUUIDv4;
+    private generateUUIDv5;
+    private getRandomHex;
+    private getRandomCacheKey;
+    /**
+     * Vide le cache
+     */
+    clearCache(): void;
+    /**
+     * Méthode utilitaire pour générer un identifiant unique
+     */
+    static generateId(format: string, customHandlers?: Record<string, CustomHandler>): string;
+    static exposeToGlobal(): void;
+}
+declare const IdentifierGeneratorHandlers: {
+    timestamp: () => string;
+    date: () => string;
+    time: () => string;
+    counter: () => string;
+    env: (envVar: string) => string;
+};
+declare const _default: {
+    IdentifierGenerator: typeof IdentifierGenerator;
+    IdentifierGeneratorHandlers: {
+        timestamp: () => string;
+        date: () => string;
+        time: () => string;
+        counter: () => string;
+        env: (envVar: string) => string;
+    };
+};
+
+export { IdentifierGenerator, IdentifierGeneratorHandlers, _default as default };
+export type { CustomHandler, RandomOptions, RandomType, TokenDefinition, UUIDOptions, UUIDVersion };