@arc-js/id-generator 0.0.1

package/index.js

@@ -0,0 +1,360 @@
+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;
+    }
+    parseToken(tokenContent) {
+        if (tokenContent.includes('{') === false) {
+            return { type: 'string', value: tokenContent };
+        }
+        const [type, optionsStr] = tokenContent.split('{', 2);
+        const optionsContent = optionsStr.slice(0, -1); 
+        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}`);
+    }
+    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
+        };
+    }
+    parseUUIDOptions(optionsStr) {
+        const defaults = {
+            version: 'v4'
+        };
+        const options = this.parseOptions(optionsStr);
+        return {
+            version: options.version || defaults.version
+        };
+    }
+    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() {
+        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() {
+        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;
+}
+var index = {
+    IdentifierGenerator,
+    IdentifierGeneratorHandlers,
+};
+
+export { IdentifierGenerator, IdentifierGeneratorHandlers, index as default };

package/index.min.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 };

package/index.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={IdentifierGenerator:IdentifierGenerator,IdentifierGeneratorHandlers:IdentifierGeneratorHandlers};export{IdentifierGenerator,IdentifierGeneratorHandlers,index as default};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/id-generator",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.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.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,19 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}