@jsarc/cooks 0.0.0

package/ts/index.ts

@@ -0,0 +1,274 @@
+import { Timez } from '@jsarc/timez';
+
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Cooks: any;
+    __bundledModules: any;
+}
+
+interface CooksOptions {
+    expires?: Date | number; 
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+
+
+type Serializable =
+    | string
+    | number
+    | boolean
+    | Date
+    | object
+    | Array<any>
+    | null
+    | undefined;
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+    const NODEENV: 'development' | 'production' | 'debug' = 'development'; // development | debug | production
+
+    const langs = ['en', 'fr'];
+    const langCodes = {
+        'fr': 'fr_FR',
+        'en': 'en_US',
+    };
+
+    const dateTimeFormatInitial = '%Y-%m-%dT%H:%M:%S.%fZ';
+    const dateFormatInitial = '%Y-%m-%d';
+    const timeFormatInitial = '%H:%M:%S.%fZ';
+
+    const dateFormatForFile = '%Y%m%d%H%M%S';
+    const dateFormat1 = '%Y/%m/%d %H:%M:%S.%fZ';
+    const dateFormat2 = '%Y/%m/%d %H:%M:%S';
+    const dateFormat3 = '%Y/%m/%d %H:%M';
+    const dateFormat4 = '%d/%m/%Y %H:%M:%S GMT%z';
+    const dateFormat5 = '%Y/%m/%d';
+    const timeFormat1 = '%H:%M:%S.%fZ';
+    const timeFormat2 = '%H:%M:%S';
+    const timeFormat3 = '%H:%M:%S.%f';
+    const pagesPossibles = [5, 10, 15, 25, 50, 100, -1];
+
+    const regExpForAlphanumeric = /^[\w\s]{1,}/;
+
+    const tabNumerique = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+    const tabAlphabetique = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
+    const tabAlphabetiqueInsensitive = [...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
+    const tabAlphanumerique = [...tabNumerique, ...tabAlphabetique];
+    const tabAlphanumeriqueInsensitive = [...tabNumerique, ...tabAlphabetiqueInsensitive];
+    
+
+
+
+
+
+
+    class Cooks {
+        private static DEFAULT_OPTIONS: CooksOptions = {
+            path: '/',
+            secure: true,
+            sameSite: 'lax' as const
+        };
+
+        public static set<T extends Serializable>(key: string, value: T, options: CooksOptions = {}): void {
+            if (!this.isBrowser()) return;
+
+            try {
+                const serializedValue = this.serialize(value);
+                const encodedValue = encodeURIComponent(serializedValue);
+                const cookieString = this.buildCookieString(key, encodedValue, options);
+
+                document.cookie = cookieString;
+            } catch (error) {
+                console.error(`Cooks: Error setting cookie "${key}":`, error);
+            }
+        }
+
+        public static get<T extends Serializable>(key: string): T | null {
+            if (!this.isBrowser()) return null;
+
+            try {
+                const cookies = this.getAllCookies();
+                const encodedValue = cookies[key];
+
+                if (!encodedValue) return null;
+
+                const decodedValue = decodeURIComponent(encodedValue);
+                return this.deserialize<T>(decodedValue);
+            } catch (error) {
+                console.error(`Cooks: Error getting cookie "${key}":`, error);
+                return null;
+            }
+        }
+
+        public static remove(key: string, path: string = '/', domain?: string): void {
+            if (!this.isBrowser()) return;
+
+            const options: CooksOptions = {
+                expires: new Date(0),
+                path,
+                domain
+            };
+
+            this.set(key, '', options);
+        }
+
+        public static has(key: string): boolean {
+            return this.get(key) !== null;
+        }
+
+        public static keys(): string[] {
+            if (!this.isBrowser()) return [];
+
+            const cookies = this.getAllCookies();
+            return Object.keys(cookies);
+        }
+
+        public static clear(): void {
+            if (!this.isBrowser()) return;
+
+            const cookies = this.getAllCookies();
+            Object.keys(cookies).forEach(key => {
+                this.remove(key);
+            });
+        }
+
+        private static serialize(value: Serializable): string {
+            if (value instanceof Date) {
+                return JSON.stringify({
+                    __type: 'Date',
+                    __value: value.toISOString()
+                });
+            }
+
+            return JSON.stringify(value);
+        }
+
+        private static deserialize<T>(value: string): T {
+            const parsed = JSON.parse(value);
+
+            if (parsed && typeof parsed === 'object' && parsed.__type === 'Date') {
+                return new Date(parsed.__value) as T;
+            }
+
+            return parsed as T;
+        }
+
+        private static buildCookieString(key: string, value: string, options: CooksOptions): string {
+            const mergedOptions = { ...this.DEFAULT_OPTIONS, ...options };
+            let cookieString = `${key}=${value}`;
+
+            if (mergedOptions.expires !== undefined) {
+                let expirationDate: Date;
+
+                if (typeof mergedOptions.expires === 'number') {
+                    const expirationDateInitial = new Timez().add(mergedOptions.expires, 'seconds').toDate();
+
+                    if(!!expirationDateInitial) {
+                        expirationDate = expirationDateInitial;
+                    } else {
+                        expirationDate = new Date();
+                    }
+
+                } else {
+
+                    expirationDate = mergedOptions.expires;
+                }
+
+                cookieString += `; expires=${expirationDate.toUTCString()}`;
+            }
+
+            if (mergedOptions.path) cookieString += `; path=${mergedOptions.path}`;
+            if (mergedOptions.domain) cookieString += `; domain=${mergedOptions.domain}`;
+            if (mergedOptions.secure) cookieString += `; secure`;
+            if (mergedOptions.sameSite) cookieString += `; samesite=${mergedOptions.sameSite}`;
+
+            if(NODEENV === 'development') {
+                console.log(`Cooks - buildCookieString | cookieString:: `, cookieString);
+            }
+
+            return cookieString;
+        }
+
+        private static getAllCookies(): Record<string, string> {
+            return document.cookie
+                .split(';')
+                .reduce((cookies, cookie) => {
+                    const [key, value] = cookie.split('=').map(part => part.trim());
+                    if (key) {
+                        cookies[key] = value || '';
+                    }
+                    return cookies;
+                }, {} as Record<string, string>);
+        }
+
+        private static isBrowser(): boolean {
+            return typeof window !== 'undefined' && typeof document !== 'undefined';
+        }
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).Cooks = Cooks;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        (window as any).Cooks = Cooks;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Cooks,
+        Cooks: Cooks,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = Cooks;
+        (global as any).Cooks = Cooks;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = Cooks;
+        (window as any).Cooks = Cooks;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = Cooks;
+        exports.Cooks = Cooks;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type CooksElementTypeGF = typeof globalFunct.Cooks;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const CooksElementGF: CooksElementTypeGF = globalFunct.Cooks;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+export {
+	defaultElementGF as default,
+	CooksElementGF as Cooks,
+};
+export type {
+	DefaultElementTypeGF,
+	CooksElementTypeGF,
+};

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false,
+        
+        "strict": false,
+        "noImplicitAny": false,
+        "strictNullChecks": false,
+        "strictFunctionTypes": false,
+        "strictBindCallApply": false,
+        "strictPropertyInitialization": false,
+        "noImplicitThis": false,
+        "alwaysStrict": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}