aprog 2.1.9 → 2.2.1

package/README.md

@@ -22,6 +22,16 @@ or
 npm i aprog -D 
 ```
 
+Завантаження `Constructs`
+```shell
+node node_modules/aprog/publish.js
+```
+
+Завантаження `Constructs` з перезаписом
+```shell
+node node_modules/aprog/publish.js --force
+```
+
 ### Basic Usage
 
 Підключення router:
@@ -139,16 +149,6 @@ onInput: (event) => {
 <input value="4">
 ```
 
-Завантаження `Constructs`
-```shell
-node node_modules/aprog/publish.js
-```
-
-Завантаження `Constructs` з перезаписом
-```shell
-node node_modules/aprog/publish.js --force
-```
-
 ########## ########## ########## ########## ##########
 
 Загальний список методів:
@@ -175,6 +175,9 @@ node node_modules/aprog/publish.js --force
 
 - *uniquePage({key: "default", callbackTrue: () => {"empty"}, callbackFalse: () => {"empty"}, timer: "default")*
 
+- *const wrap = (value) => new SmartWrapper(value);*
+- *wrap(data).get("key").val*
+
 ### Info
 
 - Додано безплатний чат із `Gemini`

package/index.js

@@ -22,5 +22,6 @@ export {
 } from './src/html.js';
 export { prism } from "./src/prism.js";
 export { uniquePage } from "./src/pages.js";
-export { default as AprogClass } from './src/classes/AprogClass.js';
+export { state, wrap } from "./src/helper.js";
+export { default as StateWrapper } from './src/classes/StateWrapper.js';
 export { default as SmartWrapper } from './src/classes/SmartWrapper.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aprog",
-  "version": "2.1.9",
+  "version": "2.2.1",
   "description": "Допоміжна JavaScript-бібліотека для проєктів",
   "main": "index.js",
   "exports": {

package/src/classes/SmartWrapper.js

@@ -1,39 +1,158 @@
 class SmartWrapper {
     constructor(value) {
         this._value = value;
+    }
+
+    /**
+     * Отримати значення по ключу
+     * @param {string|number} key
+     * @param {*} def
+     * @returns {SmartWrapper}
+     */
+    get(key, def = null) {
+        if (this._value === null || this._value === undefined) {
+            return new SmartWrapper(def);
+        }
+
+        if (typeof this._value === 'object') {
+            if (Array.isArray(this._value)) {
+                return new SmartWrapper(this._value[key] ?? def);
+            }
 
-        return new Proxy(this, {
-            get: (target, prop) => {
-                if (prop === 'val') return () => target._value;
-                if (prop === 'isNull') return () => target._value === null || target._value === undefined;
-                if (prop === 'toArray') return () => Array.isArray(target._value) ? target._value : Object.values(target._value ?? {});
-                if (prop === 'toObject') return () => (typeof target._value === 'object' ? target._value : {});
-                if (prop === 'toString') return () => typeof target._value === 'string' ? target._value : String(target._value ?? '');
-                if (prop === 'get') {
-                    // підтримка dot notation
-                    return (path, def = null) => {
-                        const keys = path.split('.');
-                        let current = target._value;
-                        for (const key of keys) {
-                            if (current && (typeof current === 'object') && key in current) {
-                                current = current[key];
-                            } else {
-                                return new SmartWrapper(def);
-                            }
-                        }
-                        return new SmartWrapper(current);
-                    };
-                }
-
-                // доступ до властивості як ланцюг
-                if (target._value && typeof target._value === 'object' && prop in target._value) {
-                    return new SmartWrapper(target._value[prop]);
-                }
-
-                // fallback — undefined
-                return new SmartWrapper(undefined);
+            if (Object.prototype.hasOwnProperty.call(this._value, key)) {
+                return new SmartWrapper(this._value[key]);
             }
-        });
+        }
+
+        return new SmartWrapper(def);
+    }
+
+    /**
+     * Отримати вкладене значення за шляхом 'a.b.c'
+     * @param {string} path
+     * @param {*} def
+     * @returns {SmartWrapper}
+     */
+    path(path, def = null) {
+        const keys = path.split('.');
+        let current = new SmartWrapper(this._value);
+        for (const key of keys) {
+            current = current.get(key);
+        }
+        return current.isNull ? new SmartWrapper(def) : current;
+    }
+
+    /**
+     * Перевірити чи існує ключ
+     * @param {string|number} key
+     * @returns {boolean}
+     */
+    has(key) {
+        if (this._value === null || this._value === undefined) return false;
+        if (Array.isArray(this._value)) return key in this._value;
+        if (typeof this._value === 'object') return Object.prototype.hasOwnProperty.call(this._value, key);
+        return false;
+    }
+
+    /**
+     * Повернути тільки вказані ключі
+     * @param {string[]} keys
+     * @returns {SmartWrapper}
+     */
+    only(keys = []) {
+        if (typeof this._value !== 'object' || this._value === null) {
+            return new SmartWrapper({});
+        }
+
+        const result = {};
+        for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(this._value, key)) {
+                result[key] = this._value[key];
+            }
+        }
+
+        return new SmartWrapper(result);
+    }
+
+    /**
+     * Встановити нове значення по ключу
+     * @param {string|number} key
+     * @param {*} val
+     * @returns {SmartWrapper}
+     */
+    set(key, val) {
+        if (typeof this._value === 'object' && this._value !== null) {
+            return new SmartWrapper({ ...this._value, [key]: val });
+        }
+        return new SmartWrapper({ [key]: val });
+    }
+
+    /**
+     * Пройтись по значеннях як по масиву або об'єкту
+     * @param {function(*, string|number): *} callback
+     * @returns {SmartWrapper}
+     */
+    map(callback) {
+        if (Array.isArray(this._value)) {
+            return new SmartWrapper(this._value.map(callback));
+        }
+
+        if (typeof this._value === 'object' && this._value !== null) {
+            return new SmartWrapper(
+                Object.entries(this._value).map(([key, val]) => callback(val, key))
+            );
+        }
+
+        return new SmartWrapper([]);
+    }
+
+    /**
+     * Отримати реальне значення
+     * @returns {*}
+     */
+    get val() {
+        return this._value;
+    }
+
+    /**
+     * Чи є значення null або undefined
+     * @returns {boolean}
+     */
+    get isNull() {
+        return this._value === null || this._value === undefined;
+    }
+
+    /**
+     * Привести до масиву (рекурсивно)
+     * @returns {Array}
+     */
+    get toArray() {
+        if (Array.isArray(this._value)) return this._value;
+        if (typeof this._value === 'object' && this._value !== null) return Object.values(this._value);
+        return [];
+    }
+
+    /**
+     * Привести до об'єкта (рекурсивно)
+     * @returns {Object}
+     */
+    get toObject() {
+        if (typeof this._value === 'object' && this._value !== null) return this._value;
+        return {};
+    }
+
+    /**
+     * Привести до рядка
+     * @returns {string}
+     */
+    get toString() {
+        if (typeof this._value === 'string') return this._value;
+        if (typeof this._value === 'number' || typeof this._value === 'boolean') {
+            return String(this._value);
+        }
+        if (Array.isArray(this._value)) return JSON.stringify(this._value);
+        if (typeof this._value === 'object' && this._value !== null) return JSON.stringify(Object.values(this._value));
+        return '';
     }
 }
 

package/src/classes/StateWrapper.js

@@ -0,0 +1,59 @@
+class StateWrapper {
+    #value;
+
+    constructor(initialValue) {
+        this.#value = initialValue;
+
+        return new Proxy(this, {
+            get: (target, prop) => {
+                if (prop === 'set') {
+                    return (newValue) => {
+                        target.#value = typeof newValue === 'function'
+                            ? newValue(target.#value)
+                            : newValue;
+                    };
+                }
+
+                if (prop === 'value') {
+                    return target.#value;
+                }
+
+                if (typeof target.#value === 'object' && target.#value !== null && prop in target.#value) {
+                    return target.#value[prop];
+                }
+
+                return Reflect.get(target, prop);
+            },
+
+            set: (target, prop, val) => {
+                if (typeof target.#value === 'object' && target.#value !== null) {
+                    target.#value[prop] = val;
+                    return true;
+                }
+                return false;
+            },
+
+            apply: (_, __, ___) => {
+                return target.#value;
+            },
+
+            getPrototypeOf: (target) => {
+                return Object.getPrototypeOf(target.#value);
+            },
+
+            has: (target, key) => {
+                return key in target.#value;
+            },
+
+            ownKeys: (target) => {
+                return Reflect.ownKeys(target.#value);
+            },
+
+            getOwnPropertyDescriptor: (target, key) => {
+                return Object.getOwnPropertyDescriptor(target.#value, key);
+            }
+        });
+    }
+}
+
+export default StateWrapper;

package/src/constructs/ButtonConstructor.js

@@ -28,7 +28,7 @@ export const ButtonConstructor = {
     } = {}) {
         return this.is = button({
             id: id || GUID(),
-            class: `${this.class} btn ${className} disabled`,
+            class: `${this.class} btn ${className} disabled`.trim(),
             style: style,
             ...(type && {type: type}),
             value: text,

package/src/constructs/InputConstructor.js

@@ -31,7 +31,7 @@ export const InputConstructor = {
     } = {}) {
         return this.is = input({
             id: id || GUID(),
-            class: `${this.class} input ${className}`,
+            class: `${this.class} input ${className}`.trim(),
             style: style,
             ...(type && {type: type}),
             focus: focus,

package/src/constructs/SelectConstructor.js

@@ -0,0 +1,45 @@
+import {GUID, select} from "aprog";
+
+/**
+ * AprogJS Constructor
+ * --- SelectConstructor ---
+ * Copyright (c) 2025 AlexProger.
+ */
+export const SelectConstructor = {
+    /**
+     * create HTMLElement
+     */
+    constructor() {
+        const instance = Object.create(this);
+        instance.class = GUID();
+        return instance;
+    },
+
+    /**
+     * set HTMLElement
+     */
+    element({
+        id = undefined,
+        className = "",
+        style = {},
+        option = undefined,
+        options = undefined,
+        callback = () => {},
+    } = {}) {
+        return this.is = select({
+            id: id || GUID(),
+            class: `${this.class} input ${className}`.trim(),
+            style: style,
+            ...(option && {option: option}),
+            ...(options && {options: options}),
+            onChange: callback,
+        });
+    },
+
+    /**
+     * get target [HTMLElement]
+     */
+    get target() {
+        return this?.is;
+    }
+};

package/src/helper.js

@@ -0,0 +1,6 @@
+import StateWrapper from "./classes/StateWrapper.js";
+import SmartWrapper from "./classes/SmartWrapper.js";
+
+export const state = (value) => new StateWrapper(value);
+
+export const wrap = (value) => new SmartWrapper(value);

package/src/classes/AprogClass.js

@@ -1,23 +0,0 @@
-class AprogClass {
-    #states = [];
-    #cursor = 0;
-
-    useState(initialValue) {
-        const index = this.#cursor;
-
-        if (this.#states[index] === undefined) {
-            this.#states[index] = initialValue;
-        }
-
-        const setState = (newValue) => {
-            const current = this.#states[index];
-            this.#states[index] = typeof newValue === "function" ? newValue(current) : newValue;
-        };
-
-        const value = this.#states[index];
-        this.#cursor++;
-        return [value, setState];
-    }
-}
-
-export default AprogClass;