@arc-js/qust 0.0.1

package/index.js

@@ -0,0 +1,277 @@
+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 };
+    }
+    stringify(obj) {
+        if (!obj || typeof obj !== 'object') {
+            return '';
+        }
+        const parts = [];
+        this.processObject('', obj, parts, 0);
+        return parts.length > 0 ? `?${parts.join('&')}` : '';
+    }
+    parse(queryString) {
+        if (!queryString || typeof queryString !== 'string') {
+            return {};
+        }
+        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);
+    }
+    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;
+        }
+        const encodedKey = this.encodeKey(prefix);
+        const encodedValue = this.options.encode && typeof value === 'string'
+            ? encodeURIComponent(value)
+            : String(value);
+        parts.push(`${encodedKey}=${encodedValue}`);
+    }
+    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;
+        }
+    }
+    encodeKey(key) {
+        if (!this.options.encode) {
+            return key;
+        }
+        const parts = [];
+        let currentPart = '';
+        for (let i = 0; i < key.length; i++) {
+            const char = key[i];
+            if (char === '[' || char === ']') {
+                if (currentPart) {
+                    parts.push(encodeURIComponent(currentPart));
+                    currentPart = '';
+                }
+                parts.push(char);
+            }
+            else {
+                currentPart += char;
+            }
+        }
+        if (currentPart) {
+            parts.push(encodeURIComponent(currentPart));
+        }
+        return parts.join('');
+    }
+    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++; 
+                    }
+                    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];
+                }
+            }
+        }
+    }
+    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;
+    }
+    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;
+    }
+    isPrimitive(value) {
+        return value === null ||
+            typeof value !== 'object' &&
+                typeof value !== 'function';
+    }
+    setOptions(newOptions) {
+        this.options = { ...this.options, ...newOptions };
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Qust = Qust;
+        }
+    }
+}
+const qust = {
+    stringify(obj, options) {
+        return new Qust(options).stringify(obj);
+    },
+    parse(queryString, options) {
+        return new Qust(options).parse(queryString);
+    }
+};
+if (typeof window !== "undefined") {
+    window.Qust = Qust;
+    window.qust = qust;
+}
+
+export { Qust, qust as default, qust };

package/index.min.d.ts

@@ -0,0 +1,88 @@
+type Primitive = string | number | boolean | null | undefined;
+type QueryValue = Primitive | Primitive[] | {
+    [key: string]: QueryValue;
+};
+type QueryObject = {
+    [key: string]: QueryValue;
+};
+declare global {
+    interface Window {
+        Qust: typeof Qust;
+        qust: any;
+    }
+}
+interface QustOptions {
+    arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'none';
+    arraySeparator?: string;
+    skipNull?: boolean;
+    skipEmptyString?: boolean;
+    encode?: boolean;
+    decode?: boolean;
+    depth?: number;
+}
+declare class Qust {
+    private options;
+    constructor(options?: QustOptions);
+    /**
+     * Convertit un objet en query string
+     */
+    stringify(obj: QueryObject): string;
+    /**
+     * Convertit une query string en objet
+     */
+    parse<T = QueryObject>(queryString: string): T;
+    /**
+     * Traite récursivement un objet pour la stringification
+     */
+    private processObject;
+    /**
+     * Traite les tableaux selon le format spécifié
+     */
+    private processArray;
+    /**
+     * Encode une clé de manière sélective
+     * N'encode pas les caractères [] pour préserver la lisibilité
+     */
+    private encodeKey;
+    /**
+     * Définit une valeur dans l'objet résultat lors du parsing
+     */
+    private setValue;
+    /**
+     * Transforme les structures en tableaux lorsque nécessaire
+     */
+    private transformArrays;
+    /**
+     * Parse une valeur string en type approprié
+     */
+    private parseValue;
+    /**
+     * Vérifie si une valeur est primitive
+     */
+    private isPrimitive;
+    /**
+     * Met à jour les options
+     */
+    setOptions(newOptions: Partial<QustOptions>): void;
+    /**
+     * Retourne les options actuelles
+     */
+    getOptions(): Required<QustOptions>;
+    /**
+     * Exposition globale de la classe
+     */
+    static exposeToGlobal(): void;
+}
+declare const qust: {
+    /**
+     * Convertit un objet en query string avec options par défaut
+     */
+    stringify(obj: QueryObject, options?: QustOptions): string;
+    /**
+     * Convertit une query string en objet avec options par défaut
+     */
+    parse<T = QueryObject>(queryString: string, options?: QustOptions): T;
+};
+
+export { Qust, qust as default, qust };
+export type { QueryObject, QueryValue, QustOptions };

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

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/qust",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.1",
+  "description": "Qust est une bibliothèque TypeScript ultra-légère et performante pour la sérialisation et désérialisation d'objets en chaînes de requête (query strings). Elle offre une API simple et puissante pour manipuler les paramètres d'URL avec support des types complexes, des tableaux, des objets imbriqués et des options avancées.",
+  "main": "index.js",
+  "keywords": [],
+  "author": "INICODE <contact@inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@arc-js/qust",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {}
+}