@arc-js/qust 0.0.0

package/index.ts

@@ -0,0 +1,456 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Qust: any;
+    qust: any;
+    __bundledModules: any;
+}
+
+interface QustOptions {
+    arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'none';
+    arraySeparator?: string;
+    skipNull?: boolean;
+    skipEmptyString?: boolean;
+    encode?: boolean;
+    decode?: boolean;
+    depth?: number;
+}
+
+
+type Primitive = string | number | boolean | null | undefined;
+
+type QueryValue = Primitive | Primitive[] | { [key: string]: QueryValue };
+
+type QueryObject = { [key: string]: QueryValue };
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+
+
+
+
+
+    const DEFAULT_OPTIONS: Required<QustOptions> = {
+        arrayFormat: 'bracket',
+        arraySeparator: ',',
+        skipNull: true,
+        skipEmptyString: false,
+        encode: true,
+        decode: true,
+        depth: 10
+    };
+
+    class Qust {
+        private options: Required<QustOptions>;
+
+        constructor(options: QustOptions = {}) {
+            this.options = { ...DEFAULT_OPTIONS, ...options };
+        }
+
+        stringify(obj: QueryObject): string {
+            if (!obj || typeof obj !== 'object') {
+                return '';
+            }
+
+            const parts: string[] = [];
+            this.processObject('', obj, parts, 0);
+
+            return parts.length > 0 ? `?${parts.join('&')}` : '';
+        }
+
+        parse<T = QueryObject>(queryString: string): T {
+            if (!queryString || typeof queryString !== 'string') {
+                return {} as T;
+            }
+
+            const cleanString = queryString.startsWith('?')
+                ? queryString.slice(1)
+                : queryString;
+
+            if (!cleanString) {
+                return {} as T;
+            }
+
+            const result: QueryObject = {};
+            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) as T;
+        }
+
+        private processObject(
+            prefix: string,
+            value: QueryValue,
+            parts: string[],
+            depth: number
+        ): void {
+            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}`);
+        }
+
+        private processArray(
+            prefix: string,
+            array: Primitive[],
+            parts: string[],
+            depth: number
+        ): void {
+            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;
+            }
+        }
+
+        private encodeKey(key: string): string {
+            if (!this.options.encode) {
+                return key;
+            }
+
+            const parts: string[] = [];
+            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('');
+        }
+
+        private setValue(obj: QueryObject, key: string, value: string | undefined): void {
+            const matches = key.match(/([^\[\]]+)|(\[\])/g);
+
+            if (!matches) {
+                if (value !== undefined) {
+                    obj[key] = this.parseValue(value);
+                }
+                return;
+            }
+
+            let current: any = 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];
+                    }
+                }
+            }
+        }
+
+        private transformArrays(obj: any): any {
+            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: any = {};
+            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: any[] = [];
+                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;
+        }
+
+        private parseValue(value: string): Primitive {
+            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;
+        }
+
+        private isPrimitive(value: any): boolean {
+            return value === null ||
+                typeof value !== 'object' &&
+                typeof value !== 'function';
+        }
+
+        setOptions(newOptions: Partial<QustOptions>): void {
+            this.options = { ...this.options, ...newOptions };
+        }
+
+        getOptions(): Required<QustOptions> {
+            return { ...this.options };
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                window.Qust = Qust;
+            }
+        }
+    }
+
+    const qust = {
+
+        stringify(obj: QueryObject, options?: QustOptions): string {
+            return new Qust(options).stringify(obj);
+        },
+
+        parse<T = QueryObject>(queryString: string, options?: QustOptions): T {
+            return new Qust(options).parse<T>(queryString);
+        }
+    };
+
+    if (typeof window !== "undefined") {
+        window.Qust = Qust;
+        window.qust = qust;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: qust,
+        Qust: Qust,
+        qust: qust,
+    };
+    
+    globalFunctModule.default = {...(globalFunctModule?.default || {}), Qust: Qust};
+    globalFunctModule.default = {...(globalFunctModule?.default || {}), qust: qust};
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = qust;
+        (global as any).Qust = Qust;
+        (global as any).qust = qust;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = qust;
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = __bundledModules;
+        module.exports.default = qust;
+        module.exports.Qust = Qust;
+        module.exports.qust = qust;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = qust;
+        exports.Qust = Qust;
+        exports.qust = qust;
+    }
+	return __bundledModules;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type QustElementTypeGF = typeof globalFunct.Qust;
+
+type qustElementTypeGF = typeof globalFunct.qust;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const QustElementGF: QustElementTypeGF = globalFunct.Qust;
+
+const qustElementGF: qustElementTypeGF = globalFunct.qust;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+export {
+	QustElementGF as Qust,
+	qustElementGF as qust,
+};
+
+export default defaultElementGF;
+if (typeof module !== 'undefined' && module.exports) {
+	module.exports = {
+		Qust: QustElementGF,
+		qust: qustElementGF,
+	};
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+	module.exports.default = globalFunct?.default;
+}
+
+export type { QustElementTypeGF, qustElementTypeGF };
+
+export type { DefaultElementTypeGF };