@reidelsaltres/pureper 0.2.32 → 0.2.34

package/src/foundation/TripletDecorator.ts

@@ -1,5 +1,5 @@
 import { AnyConstructor, UniHtml } from "../index.js";
-import Triplet, { TripletStruct } from "./Triplet.js"
+import Triplet, { RegistryCapture, TripletStruct } from "./Triplet.js"
 
 export function ReComponent(settings: TripletStruct, tag: string) {
     return (ctor: Function) => {
@@ -12,6 +12,12 @@ export function ReComponent(settings: TripletStruct, tag: string) {
         const triplet: Triplet = new Triplet(settings);
 
         triplet.register("markup", tag);
+
+        const paths: string[] = [];
+        if (settings.markupURL) paths.push(settings.markupURL);
+        if (settings.cssURL) paths.push(settings.cssURL);
+        if (settings.ltCssURL) paths.push(settings.ltCssURL);
+        if (paths.length > 0) RegistryCapture.capture(ctor, paths);
     }
 }
 export function RePage(settings: TripletStruct, route: string) {
@@ -25,6 +31,12 @@ export function RePage(settings: TripletStruct, route: string) {
         const triplet: Triplet = new Triplet(settings);
 
         triplet.register("router", route);
+
+        const paths: string[] = [];
+        if (settings.markupURL) paths.push(settings.markupURL);
+        if (settings.cssURL) paths.push(settings.cssURL);
+        if (settings.ltCssURL) paths.push(settings.ltCssURL);
+        if (paths.length > 0) RegistryCapture.capture(ctor, paths);
     }
 }
 
@@ -53,6 +65,12 @@ export function ReImplementation(settings: TripletStruct, target: string) {
         // Register adds the implementation to the existing placeholder (or creates one)
         triplet.register(target.includes("-") ? "markup" : "router", target);
 
+        const paths: string[] = [];
+        if (settings.markupURL) paths.push(settings.markupURL);
+        if (settings.cssURL) paths.push(settings.cssURL);
+        if (settings.ltCssURL) paths.push(settings.ltCssURL);
+        if (paths.length > 0) RegistryCapture.capture(ctor, paths);
+
         console.info(`[ReImplementation:${target}] registered implementation "${implName}"`);
     }
 }

package/src/foundation/engine/Expression.ts

@@ -114,18 +114,17 @@ export default class Expression {
         const context = scope.getVariables();
         let transformedCode = this.code;
 
-        // Находим Observable переменные
-        const observableVars = new Set<string>();
-        for (const [key, value] of Object.entries(context)) {
-            if (isObservable(value)) {
-                observableVars.add(key);
-            }
-        }
-
-        // Трансформируем Observable: user.name -> user.getObject().name
-        for (const varName of observableVars) {
-            const propRegex = new RegExp(`\\b${varName}\\.(?!getObject|setObject|subscribe|unsubscribe|getObserver|getMutationObserver|subscribeMutation|unsubscribeMutation)`, 'g');
-            transformedCode = transformedCode.replace(propRegex, `${varName}.getObject().`);
+        for (const [varName, value] of Object.entries(context)) {
+            if (!isObservable(value)) continue;
+
+            const propRegex = new RegExp(`\\b${varName}\\.(\\w+)`, 'g');
+            transformedCode = transformedCode.replace(propRegex, (match, propName) => {
+                // Не разворачиваем, если свойство/метод существует на самом экземпляре Observable
+                if (propName in value) {
+                    return match;
+                }
+                return `${varName}.getObject().${propName}`;
+            });
         }
 
         return transformedCode;

package/src/foundation/engine/TemplateEngine.ts

@@ -57,11 +57,13 @@ export default class TemplateEngine {
             }
             return false;
         }
-        doWork(context?: { element: Element, name: string, value: string }): void {
+        doWork(context?: { element: Element, name: string, value: string | boolean }): void {
             const { element, name, value } = context!;
-            if (value === null || value === undefined) {
+            if (value === null || value === undefined || value === false) {
                 if (element.hasAttribute(name))
                     element.removeAttribute(name);
+            } else if (value === true) {
+                element.setAttribute(name, '');
             } else {
                 element.setAttribute(name, value);
             }
@@ -256,7 +258,8 @@ export default class TemplateEngine {
                     if (!point.nextSibling) break;
                     point = point.nextSibling;
                     if (!point || point.nodeType !== Node.ELEMENT_NODE) continue;
-                    if (!point || !this.acceptNode(point as Element)) break;
+                    const tag = (point as Element).tagName;
+                    if (tag !== "ELSEIF" && tag !== "ELSE") break;
                     allParts.push({ element: point as Element, shadow: TemplateEngine.transContentToShadow(point as Element) });
                 }
 

package/src/foundation/worker/ServiceWorker.ts

@@ -18,22 +18,18 @@ export interface FetchActivityItem {
 
 export type PageSourceType = 'cache' | 'network' | 'unknown';
 
-export type CacheStrategy = 'cache-first' | 'network-first';
-export type PrecacheMode = 'precache' | 'normal' | 'disabled';
-
 /**
  * Client-side Service Worker manager for Purper SPA.
  *
  * Provides:
  * - Registration with one call (`ServiceWorker.register()`)
- * - Cache management: add / remove / list / clear
  * - Connectivity detection with reactive `online` observable
+ * - Fetch tracking for debug NetworkStatus component
+ * - Version / lifecycle management
  *
  * Usage:
  * ```ts
  * await ServiceWorker.register();              // defaults to './serviceworker.js'
- * await ServiceWorker.addToCache('/data.json');
- * await ServiceWorker.removeFromCache('/old.css');
  * ServiceWorker.online.subscribe(v => console.log('online:', v));
  * ```
  */
@@ -45,8 +41,6 @@ export default class ServiceWorker {
 
     static readonly fetchActivities: Observable<FetchActivityItem[]> = new Observable([]);
     static readonly pageSource: Observable<PageSourceType> = new Observable<PageSourceType>('unknown');
-    static readonly cacheStrategy: Observable<CacheStrategy> = new Observable<CacheStrategy>('cache-first');
-    static readonly precacheMode: Observable<PrecacheMode> = new Observable<PrecacheMode>('normal');
     private static _fetchTrackingEnabled = false;
     private static _fetchListenerBound = false;
 
@@ -125,99 +119,6 @@ export default class ServiceWorker {
         });
     }
 
-    // ── Cache Management ────────────────────────────────────────────
-
-    /** Add a single URL to the SW cache. */
-    static async addToCache(url: string): Promise<void> {
-        if (navigator.serviceWorker?.controller) {
-            this._postMessage({ type: 'CACHE_URL', url });
-            return;
-        }
-        // Fallback: use Cache API directly
-        try {
-            const cache = await caches.open('purper-v1');
-            const response = await fetch(url);
-            if (response.ok) {
-                await cache.put(url, response);
-                console.log('[ServiceWorker]: Resource cached directly:', url);
-            }
-        } catch (e) {
-            console.warn('[ServiceWorker]: Failed to cache resource:', url, e);
-        }
-    }
-
-    /** Add multiple URLs to the SW cache in one batch. */
-    static addAllToCache(urls: string[]): void {
-        this._postMessage({ type: 'CACHE_URLS', urls });
-    }
-
-    /** Remove a URL from the SW cache. Returns true if it was found and deleted. */
-    static async removeFromCache(url: string): Promise<boolean> {
-        try {
-            const data = await this._request<{ deleted: boolean }>({ type: 'REMOVE_URL', url });
-            return data.deleted;
-        } catch {
-            // Fallback
-            try {
-                const cache = await caches.open('purper-v1');
-                return await cache.delete(url);
-            } catch {
-                return false;
-            }
-        }
-    }
-
-    /** Return all URLs currently in the SW cache. */
-    static async getCacheKeys(): Promise<string[]> {
-        try {
-            const data = await this._request<{ keys: string[] }>({ type: 'GET_CACHE_KEYS' });
-            return data.keys;
-        } catch {
-            return [];
-        }
-    }
-
-    /** Wipe the entire SW cache. */
-    static async clearCache(): Promise<boolean> {
-        try {
-            const data = await this._request<{ cleared: boolean }>({ type: 'CLEAR_CACHE' });
-            return data.cleared;
-        } catch {
-            return false;
-        }
-    }
-
-    /** Check whether a URL exists in the SW cache. */
-    static async isCached(url: string): Promise<boolean> {
-        try {
-            const data = await this._request<{ cached: boolean }>({ type: 'HAS_URL', url });
-            return data.cached;
-        } catch {
-            // Fallback: CacheStorage directly
-            try {
-                return !!(await caches.match(url));
-            } catch {
-                return false;
-            }
-        }
-    }
-
-    // ── Cache Strategy & Precache Mode ────────────────────────────
-
-    static setCacheStrategy(strategy: CacheStrategy): void {
-        this.cacheStrategy.setObject(strategy);
-        this._postMessage({ type: 'SET_CACHE_STRATEGY', strategy });
-    }
-
-    static setPrecacheMode(mode: PrecacheMode): void {
-        this.precacheMode.setObject(mode);
-        this._postMessage({ type: 'SET_PRECACHE_MODE', mode });
-    }
-
-    static async getConfig(): Promise<{ strategy: CacheStrategy; precacheMode: PrecacheMode }> {
-        return this._request<{ strategy: CacheStrategy; precacheMode: PrecacheMode }>({ type: 'GET_CONFIG' });
-    }
-
     // ── Version & lifecycle ─────────────────────────────────────────
 
     /** Ask the waiting SW to activate immediately. */

package/src/index.ts

@@ -15,17 +15,18 @@ export { default as Page } from './foundation/component_api/Page.js';
 export { default as Component } from './foundation/component_api/Component.js';
 export { default as Attribute } from './foundation/component_api/Attribute.js';
 
-export { default as Triplet, TripletStruct, AccessType, REGISTRY } from './foundation/Triplet.js';
+export { default as Triplet, TripletStruct, AccessType, REGISTRY, RegistryCapture } from './foundation/Triplet.js';
 export { ReComponent, RePage, ReImplementation } from './foundation/TripletDecorator.js';
 
 export { Implementation, ImplementationStruct, Placeholder } from './foundation/Injection.js';
-export { default as Module, ModuleStruct, ModuleManager } from './foundation/Module.js';
+export { default as Module, ModuleStruct, ModuleManager, SubModule, SubModuleStruct } from './foundation/Module.js';
+export { default as CacheManager, DownloadProgress } from './foundation/CacheManager.js';
 export { default as Fetcher } from './foundation/Fetcher.js';
 
 export * from './foundation/engine/TemplateEngine.js';
 
 export { Router } from './foundation/worker/Router.js';
-export { default as ServiceWorker, ServiceWorkerConfig, FetchActivityItem, PageSourceType, CacheStrategy, PrecacheMode } from './foundation/worker/ServiceWorker.js';
+export { default as ServiceWorker, ServiceWorkerConfig, FetchActivityItem, PageSourceType } from './foundation/worker/ServiceWorker.js';
 
 export * from './foundation/Hosting.js';
 export * from './foundation/Theme.js';