@arc-js/qust 0.0.1

package/qust.all.js

@@ -0,0 +1,328 @@
+const DEFAULT_OPTIONS = {
+    arrayFormat: 'bracket',
+    arraySeparator: ',',
+    skipNull: true,
+    skipEmptyString: false,
+    encode: true,
+    decode: true,
+    depth: 10
+};
+class Qust {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Convertit un objet en query string
+     */
+    stringify(obj) {
+        if (!obj || typeof obj !== 'object') {
+            return '';
+        }
+        const parts = [];
+        this.processObject('', obj, parts, 0);
+        return parts.length > 0 ? `?${parts.join('&')}` : '';
+    }
+    /**
+     * Convertit une query string en objet
+     */
+    parse(queryString) {
+        if (!queryString || typeof queryString !== 'string') {
+            return {};
+        }
+        // Supprime le '?' initial si présent
+        const cleanString = queryString.startsWith('?')
+            ? queryString.slice(1)
+            : queryString;
+        if (!cleanString) {
+            return {};
+        }
+        const result = {};
+        const pairs = cleanString.split('&');
+        for (const pair of pairs) {
+            if (!pair)
+                continue;
+            const [encodedKey, encodedValue] = pair.split('=');
+            if (!encodedKey)
+                continue;
+            const key = this.options.decode
+                ? decodeURIComponent(encodedKey)
+                : encodedKey;
+            const value = this.options.decode && encodedValue !== undefined
+                ? decodeURIComponent(encodedValue)
+                : encodedValue;
+            this.setValue(result, key, value);
+        }
+        return this.transformArrays(result);
+    }
+    /**
+     * Traite récursivement un objet pour la stringification
+     */
+    processObject(prefix, value, parts, depth) {
+        if (depth > this.options.depth) {
+            console.warn('Qust: Profondeur maximale atteinte, arrêt de la récursion');
+            return;
+        }
+        if (value === null || value === undefined) {
+            if (!this.options.skipNull) {
+                parts.push(this.encodeKey(prefix));
+            }
+            return;
+        }
+        if (typeof value === 'string' && value === '' && this.options.skipEmptyString) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            this.processArray(prefix, value, parts, depth + 1);
+            return;
+        }
+        if (typeof value === 'object' && !this.isPrimitive(value)) {
+            for (const [key, val] of Object.entries(value)) {
+                const newPrefix = prefix ? `${prefix}[${key}]` : key;
+                this.processObject(newPrefix, val, parts, depth + 1);
+            }
+            return;
+        }
+        // Valeur primitive
+        const encodedKey = this.encodeKey(prefix);
+        const encodedValue = this.options.encode && typeof value === 'string'
+            ? encodeURIComponent(value)
+            : String(value);
+        parts.push(`${encodedKey}=${encodedValue}`);
+    }
+    /**
+     * Traite les tableaux selon le format spécifié
+     */
+    processArray(prefix, array, parts, depth) {
+        if (array.length === 0)
+            return;
+        const encodedKey = this.encodeKey(prefix);
+        switch (this.options.arrayFormat) {
+            case 'comma':
+                const values = array
+                    .map(item => this.options.encode && typeof item === 'string'
+                    ? encodeURIComponent(item)
+                    : String(item))
+                    .join(this.options.arraySeparator);
+                parts.push(`${encodedKey}=${values}`);
+                break;
+            case 'index':
+                array.forEach((item, index) => {
+                    const arrayPrefix = `${prefix}[${index}]`;
+                    this.processObject(arrayPrefix, item, parts, depth);
+                });
+                break;
+            case 'separator':
+                array.forEach(item => {
+                    const encodedValue = this.options.encode && typeof item === 'string'
+                        ? encodeURIComponent(item)
+                        : String(item);
+                    parts.push(`${encodedKey}=${encodedValue}`);
+                });
+                break;
+            case 'none':
+                array.forEach(item => {
+                    this.processObject(prefix, item, parts, depth);
+                });
+                break;
+            case 'bracket':
+            default:
+                array.forEach(item => {
+                    const arrayPrefix = `${prefix}[]`;
+                    this.processObject(arrayPrefix, item, parts, depth);
+                });
+                break;
+        }
+    }
+    /**
+     * Encode une clé de manière sélective
+     * N'encode pas les caractères [] pour préserver la lisibilité
+     */
+    encodeKey(key) {
+        if (!this.options.encode) {
+            return key;
+        }
+        // Sépare la clé en parties (texte normal et crochets)
+        const parts = [];
+        let currentPart = '';
+        for (let i = 0; i < key.length; i++) {
+            const char = key[i];
+            if (char === '[' || char === ']') {
+                // Encode la partie actuelle si elle n'est pas vide
+                if (currentPart) {
+                    parts.push(encodeURIComponent(currentPart));
+                    currentPart = '';
+                }
+                // Ajoute le crochet sans l'encoder
+                parts.push(char);
+            }
+            else {
+                currentPart += char;
+            }
+        }
+        // Encode la dernière partie si elle existe
+        if (currentPart) {
+            parts.push(encodeURIComponent(currentPart));
+        }
+        return parts.join('');
+    }
+    /**
+     * Définit une valeur dans l'objet résultat lors du parsing
+     */
+    setValue(obj, key, value) {
+        const matches = key.match(/([^\[\]]+)|(\[\])/g);
+        if (!matches) {
+            if (value !== undefined) {
+                obj[key] = this.parseValue(value);
+            }
+            return;
+        }
+        let current = obj;
+        for (let i = 0; i < matches.length; i++) {
+            const match = matches[i];
+            const isLast = i === matches.length - 1;
+            if (match === '[]') {
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                if (isLast) {
+                    if (!!value) {
+                        current.push(this.parseValue(value));
+                    }
+                }
+                else {
+                    const nextMatch = matches[i + 1];
+                    const nextIndex = parseInt(nextMatch, 10);
+                    if (!isNaN(nextIndex)) {
+                        if (current[nextIndex] === undefined) {
+                            current[nextIndex] = {};
+                        }
+                        current = current[nextIndex];
+                        i++; // Skip the next match since we used it as index
+                    }
+                    else {
+                        const newObj = {};
+                        current.push(newObj);
+                        current = newObj;
+                    }
+                }
+            }
+            else {
+                if (isLast) {
+                    if (value !== undefined) {
+                        current[match] = this.parseValue(value);
+                    }
+                }
+                else {
+                    if (current[match] === undefined || typeof current[match] !== 'object') {
+                        const nextMatch = matches[i + 1];
+                        current[match] = nextMatch === '[]' ? [] : {};
+                    }
+                    current = current[match];
+                }
+            }
+        }
+    }
+    /**
+     * Transforme les structures en tableaux lorsque nécessaire
+     */
+    transformArrays(obj) {
+        if (Array.isArray(obj)) {
+            return obj.map(item => typeof item === 'object' && item !== null
+                ? this.transformArrays(item)
+                : item);
+        }
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        const result = {};
+        const keys = Object.keys(obj);
+        const isArrayLike = keys.every(key => {
+            const num = parseInt(key, 10);
+            return !isNaN(num) && num >= 0 && num.toString() === key;
+        });
+        if (isArrayLike && keys.length > 0) {
+            const array = [];
+            keys.forEach(key => {
+                const index = parseInt(key, 10);
+                array[index] = this.transformArrays(obj[key]);
+            });
+            return array;
+        }
+        keys.forEach(key => {
+            const value = obj[key];
+            result[key] =
+                typeof value === 'object' && value !== null
+                    ? this.transformArrays(value)
+                    : value;
+        });
+        return result;
+    }
+    /**
+     * Parse une valeur string en type approprié
+     */
+    parseValue(value) {
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        if (value === 'null')
+            return null;
+        if (value === 'undefined')
+            return undefined;
+        const num = Number(value);
+        if (!isNaN(num) && value.trim() !== '')
+            return num;
+        return value;
+    }
+    /**
+     * Vérifie si une valeur est primitive
+     */
+    isPrimitive(value) {
+        return value === null ||
+            typeof value !== 'object' &&
+                typeof value !== 'function';
+    }
+    /**
+     * Met à jour les options
+     */
+    setOptions(newOptions) {
+        this.options = { ...this.options, ...newOptions };
+    }
+    /**
+     * Retourne les options actuelles
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * Exposition globale de la classe
+     */
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Qust = Qust;
+        }
+    }
+}
+// Fonctions utilitaires statiques
+const qust = {
+    /**
+     * Convertit un objet en query string avec options par défaut
+     */
+    stringify(obj, options) {
+        return new Qust(options).stringify(obj);
+    },
+    /**
+     * Convertit une query string en objet avec options par défaut
+     */
+    parse(queryString, options) {
+        return new Qust(options).parse(queryString);
+    }
+};
+// Exposition automatique en environnement browser
+if (typeof window !== "undefined") {
+    window.Qust = Qust;
+    window.qust = qust;
+}
+
+

package/qust.all.min.js

@@ -0,0 +1 @@
+let DEFAULT_OPTIONS={arrayFormat:"bracket",arraySeparator:",",skipNull:!0,skipEmptyString:!1,encode:!0,decode:!0,depth:10};class Qust{options;constructor(e={}){this.options={...DEFAULT_OPTIONS,...e}}stringify(e){return e&&"object"==typeof e&&(this.processObject("",e,e=[],0),0<e.length)?"?"+e.join("&"):""}parse(e){if(!e||"string"!=typeof e)return{};e=e.startsWith("?")?e.slice(1):e;if(!e)return{};var t,r,s,o={};for(t of e.split("&"))t&&([r,s]=t.split("="),r)&&(r=this.options.decode?decodeURIComponent(r):r,s=this.options.decode&&void 0!==s?decodeURIComponent(s):s,this.setValue(o,r,s));return this.transformArrays(o)}processObject(e,t,r,s){if(!(s>this.options.depth))if(null==t)this.options.skipNull||r.push(this.encodeKey(e));else if("string"!=typeof t||""!==t||!this.options.skipEmptyString)if(Array.isArray(t))this.processArray(e,t,r,s+1);else if("object"!=typeof t||this.isPrimitive(t)){var o=this.encodeKey(e),i=(this.options.encode&&"string"==typeof t?encodeURIComponent:String)(t);r.push(o+"="+i)}else for(var[n,a]of Object.entries(t)){n=e?`${e}[${n}]`:n;this.processObject(n,a,r,s+1)}}processArray(r,e,s,o){if(0!==e.length){let t=this.encodeKey(r);switch(this.options.arrayFormat){case"comma":var i=e.map(e=>(this.options.encode&&"string"==typeof e?encodeURIComponent:String)(e)).join(this.options.arraySeparator);s.push(t+"="+i);break;case"index":e.forEach((e,t)=>{this.processObject(r+`[${t}]`,e,s,o)});break;case"separator":e.forEach(e=>{e=(this.options.encode&&"string"==typeof e?encodeURIComponent:String)(e);s.push(t+"="+e)});break;case"none":e.forEach(e=>{this.processObject(r,e,s,o)});break;default:e.forEach(e=>{this.processObject(r+"[]",e,s,o)})}}}encodeKey(t){if(!this.options.encode)return t;var r=[];let s="";for(let e=0;e<t.length;e++){var o=t[e];"["===o||"]"===o?(s&&(r.push(encodeURIComponent(s)),s=""),r.push(o)):s+=o}return s&&r.push(encodeURIComponent(s)),r.join("")}setValue(e,t,r){var s=t.match(/([^\[\]]+)|(\[\])/g);if(s){let t=e;for(let e=0;e<s.length;e++){var o,i,n=s[e],a=e===s.length-1;"[]"===n?(Array.isArray(t)||(t=[]),a?r&&t.push(this.parseValue(r)):(o=s[e+1],o=parseInt(o,10),isNaN(o)?(i={},t.push(i),t=i):(void 0===t[o]&&(t[o]={}),t=t[o],e++))):a?void 0!==r&&(t[n]=this.parseValue(r)):(void 0!==t[n]&&"object"==typeof t[n]||(i=s[e+1],t[n]="[]"===i?[]:{}),t=t[n])}}else void 0!==r&&(e[t]=this.parseValue(r))}transformArrays(s){if(Array.isArray(s))return s.map(e=>"object"==typeof e&&null!==e?this.transformArrays(e):e);if("object"!=typeof s||null===s)return s;let r={};var e=Object.keys(s);if(e.every(e=>{var t=parseInt(e,10);return!isNaN(t)&&0<=t&&t.toString()===e})&&0<e.length){let r=[];return e.forEach(e=>{var t=parseInt(e,10);r[t]=this.transformArrays(s[e])}),r}return e.forEach(e=>{var t=s[e];r[e]="object"==typeof t&&null!==t?this.transformArrays(t):t}),r}parseValue(e){var t;return"true"===e||"false"!==e&&("null"===e?null:"undefined"!==e?(t=Number(e),isNaN(t)||""===e.trim()?e:t):void 0)}isPrimitive(e){return null===e||"object"!=typeof e&&"function"!=typeof e}setOptions(e){this.options={...this.options,...e}}getOptions(){return{...this.options}}static exposeToGlobal(){"undefined"!=typeof window&&(window.Qust=Qust)}}let qust={stringify(e,t){return new Qust(t).stringify(e)},parse(e,t){return new Qust(t).parse(e)}};"undefined"!=typeof window&&(window.Qust=Qust,window.qust=qust);

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"
+    ]
+}