smart-lifecycle 0.1.1 → 0.2.0

package/dist/rendering/templates/safe-content-selector.js

@@ -2,11 +2,11 @@
  * Implements the responsibility of selecting safe content for interpolation from parsed HTML.
  *
  * @description
- * Traverses a parse5 DocumentFragment AST and extracts only:
+ * Traverses a normalized HTML fragment and extracts only:
  * - Text nodes (excluding those inside script/style/template elements)
  * - Attribute values (excluding on*, style, and attributes inside excluded elements)
  *
- * Excluded contexts (no tokenization):
+ * Excluded contexts (no tokenization) are:
  * - Tag names and attribute names (HTML structure)
  * - Content inside `<script>`, `<style>`, `<template>` elements
  * - HTML comments
@@ -27,9 +27,9 @@ export class SafeContentSelector {
     excludedAttributePrefix = "on";
     excludedAttributes = new Set(["style"]);
     /**
-     * Extracts interpolable fragments from a parse5 DocumentFragment.
+     * Extracts interpolable fragments from a normalized HTML fragment.
      *
-     * @param parsedHtml - parse5 DocumentFragment AST
+     * @param parsedHtml - Normalized HTML fragment
      * @returns Array of safe content fragments for tokenization
      * @throws Error if parsedHtml is null or undefined
      *
@@ -40,87 +40,62 @@ export class SafeContentSelector {
      * ```
      */
     selectInterpolableFragments(parsedHtml) {
-        if (!parsedHtml) {
+        if (parsedHtml === null || parsedHtml === undefined) {
             throw new Error("ParsedHtml is required");
         }
+        if (typeof parsedHtml !== "string") {
+            throw new Error("ParsedHtml must be a string");
+        }
         const fragments = [];
-        this.traverseNode(parsedHtml, fragments, false);
-        return fragments;
-    }
-    traverseNode(node, fragments, insideExcludedElement) {
-        if (!node || typeof node !== "object")
-            return;
-        const nodeWithName = node;
-        // Handle different node types from parse5
-        if (nodeWithName.nodeName === "#document-fragment" ||
-            nodeWithName.nodeName === "#document") {
-            // Traverse children
-            const nodeWithChildren = node;
-            if (nodeWithChildren.childNodes) {
-                for (const child of nodeWithChildren.childNodes) {
-                    this.traverseNode(child, fragments, insideExcludedElement);
-                }
+        let currentIndex = 0;
+        let textStartIndex = 0;
+        while (currentIndex < parsedHtml.length) {
+            if (parsedHtml.startsWith("<!--", currentIndex)) {
+                this.pushTextFragment(parsedHtml.slice(textStartIndex, currentIndex), fragments);
+                currentIndex = this.findCommentEnd(parsedHtml, currentIndex);
+                textStartIndex = currentIndex;
+                continue;
             }
-            return;
-        }
-        // Skip comments
-        if (nodeWithName.nodeName === "#comment") {
-            return;
-        }
-        // Handle text nodes
-        if (nodeWithName.nodeName === "#text") {
-            const textNode = node;
-            if (!insideExcludedElement && textNode.value && textNode.value.trim()) {
-                // Exclude text nodes that contain HTML-like content (parse5 artifact from invalid tags)
-                if (!this.looksLikeHtmlStructure(textNode.value)) {
-                    fragments.push({
-                        content: textNode.value,
-                        type: "text",
-                    });
+            const tag = this.readTag(parsedHtml, currentIndex);
+            if (tag) {
+                this.pushTextFragment(parsedHtml.slice(textStartIndex, currentIndex), fragments);
+                if (!tag.isClosing) {
+                    this.pushAttributeFragments(tag, fragments);
                 }
-            }
-            return;
-        }
-        // Check if this is an excluded element
-        const isExcluded = this.excludedElements.has(nodeWithName.nodeName || "");
-        // Extract allowed attribute values (if not inside excluded element)
-        const elementNode = node;
-        if (!insideExcludedElement && elementNode.attrs) {
-            for (const attr of elementNode.attrs) {
-                if (this.isAttributeAllowed(attr.name) && attr.value) {
-                    fragments.push({
-                        content: attr.value,
-                        type: "attribute",
-                    });
+                currentIndex = tag.endIndex;
+                textStartIndex = currentIndex;
+                if (!tag.isClosing && !tag.isSelfClosing && this.isExcludedElement(tag)) {
+                    currentIndex = this.findExcludedElementEnd(parsedHtml, currentIndex, tag.name);
+                    textStartIndex = currentIndex;
                 }
+                continue;
             }
+            currentIndex++;
         }
-        // Traverse child nodes
-        const nodeWithChildNodes = node;
-        if (nodeWithChildNodes.childNodes) {
-            for (const child of nodeWithChildNodes.childNodes) {
-                this.traverseNode(child, fragments, insideExcludedElement || isExcluded);
-            }
+        this.pushTextFragment(parsedHtml.slice(textStartIndex), fragments);
+        return fragments;
+    }
+    pushTextFragment(content, fragments) {
+        if (content && content.trim() && !this.looksLikeHtmlStructure(content)) {
+            fragments.push({
+                content,
+                type: "text",
+            });
         }
     }
     isAttributeAllowed(attrName) {
-        // Exclude event handlers (on*)
         if (attrName.startsWith(this.excludedAttributePrefix)) {
             return false;
         }
-        // Exclude specific attributes
         if (this.excludedAttributes.has(attrName)) {
             return false;
         }
-        // Exclude attributes that look like interpolation patterns
-        // (parse5 treats invalid syntax like <{{x}}> as attributes)
         if (this.looksLikeInterpolation(attrName)) {
             return false;
         }
         return true;
     }
     looksLikeInterpolation(attrName) {
-        // Check for common interpolation delimiters in attribute name
         return (attrName.includes("{{") ||
             attrName.includes("}}") ||
             attrName.includes("${") ||
@@ -128,11 +103,165 @@ export class SafeContentSelector {
             attrName.includes("]]"));
     }
     looksLikeHtmlStructure(textValue) {
-        // Text nodes that look like HTML tags are artifacts from invalid syntax
-        // (e.g., <{{tag}}> becomes a text node "<{{tag}}>")
-        // Exclude if it starts with '<' and contains '>'
         const trimmed = textValue.trim();
         return trimmed.startsWith("<") && trimmed.includes(">");
     }
+    findCommentEnd(html, startIndex) {
+        const commentEndIndex = html.indexOf("-->", startIndex + 4);
+        return commentEndIndex === -1 ? html.length : commentEndIndex + 3;
+    }
+    readTag(html, startIndex) {
+        if (html[startIndex] !== "<") {
+            return null;
+        }
+        const tagEndIndex = this.findTagEnd(html, startIndex);
+        if (tagEndIndex === -1) {
+            return null;
+        }
+        const tagContent = html.slice(startIndex + 1, tagEndIndex);
+        const trimmedTagContent = tagContent.trim();
+        if (!trimmedTagContent) {
+            return null;
+        }
+        if (tagContent.includes("<")) {
+            return null;
+        }
+        const firstCharacter = trimmedTagContent[0];
+        if (!this.isTagStartCharacter(firstCharacter)) {
+            return null;
+        }
+        const isClosing = firstCharacter === "/";
+        const isSelfClosing = trimmedTagContent.endsWith("/");
+        const nameMatch = trimmedTagContent.match(isClosing ? /^\/\s*([^\s/>]+)/ : /^([^\s/>]+)/);
+        if (!nameMatch) {
+            return null;
+        }
+        const name = nameMatch[1].toLowerCase();
+        const attributesSource = isClosing
+            ? ""
+            : trimmedTagContent.slice(nameMatch[0].length);
+        const attributes = isClosing
+            ? []
+            : this.readAttributes(attributesSource, isSelfClosing);
+        return {
+            name,
+            isClosing,
+            isSelfClosing,
+            attributes,
+            endIndex: tagEndIndex + 1,
+        };
+    }
+    findTagEnd(html, startIndex) {
+        let currentIndex = startIndex + 1;
+        let activeQuote = null;
+        while (currentIndex < html.length) {
+            const currentCharacter = html[currentIndex];
+            if (activeQuote) {
+                if (currentCharacter === activeQuote) {
+                    activeQuote = null;
+                }
+            }
+            else if (currentCharacter === '"' || currentCharacter === "'") {
+                activeQuote = currentCharacter;
+            }
+            else if (currentCharacter === ">") {
+                return currentIndex;
+            }
+            currentIndex++;
+        }
+        return -1;
+    }
+    isTagStartCharacter(character) {
+        return /[A-Za-z!/]/.test(character) || character === "/" || character === "?";
+    }
+    readAttributes(attributesSource, isSelfClosing) {
+        const attributes = [];
+        const sanitizedSource = isSelfClosing
+            ? attributesSource.replace(/\/\s*$/, "")
+            : attributesSource;
+        let currentIndex = 0;
+        while (currentIndex < sanitizedSource.length) {
+            while (currentIndex < sanitizedSource.length &&
+                /\s/.test(sanitizedSource[currentIndex])) {
+                currentIndex++;
+            }
+            if (currentIndex >= sanitizedSource.length) {
+                break;
+            }
+            if (/[<>/]/.test(sanitizedSource[currentIndex])) {
+                break;
+            }
+            const nameStartIndex = currentIndex;
+            while (currentIndex < sanitizedSource.length &&
+                !/[\s=/>]/.test(sanitizedSource[currentIndex])) {
+                currentIndex++;
+            }
+            const name = sanitizedSource.slice(nameStartIndex, currentIndex);
+            while (currentIndex < sanitizedSource.length &&
+                /\s/.test(sanitizedSource[currentIndex])) {
+                currentIndex++;
+            }
+            let value = "";
+            if (sanitizedSource[currentIndex] === "=") {
+                currentIndex++;
+                while (currentIndex < sanitizedSource.length &&
+                    /\s/.test(sanitizedSource[currentIndex])) {
+                    currentIndex++;
+                }
+                const quoteCharacter = sanitizedSource[currentIndex];
+                if (quoteCharacter === '"' || quoteCharacter === "'") {
+                    currentIndex++;
+                    const valueStartIndex = currentIndex;
+                    while (currentIndex < sanitizedSource.length &&
+                        sanitizedSource[currentIndex] !== quoteCharacter) {
+                        currentIndex++;
+                    }
+                    value = sanitizedSource.slice(valueStartIndex, currentIndex);
+                    if (currentIndex < sanitizedSource.length) {
+                        currentIndex++;
+                    }
+                }
+                else {
+                    const valueStartIndex = currentIndex;
+                    while (currentIndex < sanitizedSource.length &&
+                        !/[\s>]/.test(sanitizedSource[currentIndex])) {
+                        currentIndex++;
+                    }
+                    value = sanitizedSource.slice(valueStartIndex, currentIndex);
+                }
+            }
+            if (name) {
+                attributes.push({
+                    name,
+                    value,
+                });
+            }
+        }
+        return attributes;
+    }
+    pushAttributeFragments(tag, fragments) {
+        for (const attribute of tag.attributes) {
+            if (this.isAttributeAllowed(attribute.name) && attribute.value) {
+                fragments.push({
+                    content: attribute.value,
+                    type: "attribute",
+                });
+            }
+        }
+    }
+    isExcludedElement(tag) {
+        return this.excludedElements.has(tag.name);
+    }
+    findExcludedElementEnd(html, startIndex, tagName) {
+        const closingTagPattern = new RegExp(`</\\s*${tagName}\\b`, "i");
+        const remainingHtml = html.slice(startIndex);
+        const closingTagMatch = closingTagPattern.exec(remainingHtml);
+        if (!closingTagMatch || closingTagMatch.index === undefined) {
+            return html.length;
+        }
+        const closingTagStartIndex = startIndex + closingTagMatch.index;
+        const closingTagEndIndex = this.findTagEnd(html, closingTagStartIndex);
+        return closingTagEndIndex === -1 ? html.length : closingTagEndIndex + 1;
+    }
 }
 //# sourceMappingURL=safe-content-selector.js.map

package/dist/rendering/templates/template-compilation-cache.d.ts

@@ -32,14 +32,16 @@ export declare class TemplateCompilationCache {
      * Generates a cache key from componentId and template content.
      *
      * @description
-     * Uses SHA-1 hash of template to ensure different resolved templates
-     * (due to different constants/rules) produce different cache keys.
+     * Uses a small deterministic non-cryptographic hash of the template to
+     * ensure different resolved templates (due to different constants/rules)
+     * produce different cache keys without relying on Node.js builtins.
      *
      * @param componentId - Component selector (tag name)
      * @param template - Resolved template string (after static binding resolution)
      * @returns Cache key combining componentId and template hash
      */
     private generateCacheKey;
+    private hashTemplate;
     /**
      * Gets cached compiled template or compiles and caches it.
      *

package/dist/rendering/templates/template-compilation-cache.js

@@ -1,4 +1,3 @@
-import { createHash } from "crypto";
 /**
  * Implements the responsibility of caching compiled templates.
  *
@@ -31,20 +30,26 @@ export class TemplateCompilationCache {
      * Generates a cache key from componentId and template content.
      *
      * @description
-     * Uses SHA-1 hash of template to ensure different resolved templates
-     * (due to different constants/rules) produce different cache keys.
+     * Uses a small deterministic non-cryptographic hash of the template to
+     * ensure different resolved templates (due to different constants/rules)
+     * produce different cache keys without relying on Node.js builtins.
      *
      * @param componentId - Component selector (tag name)
      * @param template - Resolved template string (after static binding resolution)
      * @returns Cache key combining componentId and template hash
      */
     generateCacheKey(componentId, template) {
-        const hash = createHash("sha1")
-            .update(template)
-            .digest("hex")
-            .substring(0, 8);
+        const hash = this.hashTemplate(template);
         return `${componentId}:${hash}`;
     }
+    hashTemplate(template) {
+        let hash = 2166136261;
+        for (let currentIndex = 0; currentIndex < template.length; currentIndex++) {
+            hash ^= template.charCodeAt(currentIndex);
+            hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(16).padStart(8, "0");
+    }
     /**
      * Gets cached compiled template or compiles and caches it.
      *

package/package.json

@@ -1,12 +1,30 @@
 {
   "name": "smart-lifecycle",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A tiny lifecycle-focused framework for building reactive web components",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./bootstrap": {
+      "types": "./dist/bootstrap.d.ts",
+      "import": "./dist/bootstrap.js",
+      "default": "./dist/bootstrap.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
-    "dist",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.js.map",
+    "!dist/**/*.d.ts.map",
+    "!dist/browser/**",
     "README.md",
     "LICENSE"
   ],
@@ -14,18 +32,23 @@
     "access": "public"
   },
   "scripts": {
-    "build:lib": "tsc -p tsconfig.json",
-    "build:prod": "npm run build:lib && rollup -c rollup.config.mjs",
+    "clean:dist": "node scripts/clean-dist.mjs",
+    "build:lib": "npm run clean:dist && tsc -p tsconfig.json",
+    "build:browser": "rollup -c rollup.config.mjs",
+    "build:prod": "npm run build:lib && npm run build:browser",
+    "build:release": "npm run build:prod && node scripts/prepare-release-artifacts.mjs",
     "build:examples": "node scripts/build-examples.mjs",
-    "build": "npm run build:lib && npm run build:examples",
+    "build": "npm run build:prod && npm run build:examples",
     "pretest": "node scripts/guardrails.mjs && node scripts/check-no-browser-in-node-tests.mjs",
     "serve:dev": "node scripts/serve-examples.mjs",
     "serve:dist": "node scripts/serve-dist.mjs",
-    "test": "cross-env SKIP_WEBSERVER=1 playwright test --project=unit --project=integration",
+    "test": "npm run test:unit && npm run test:integration && npm run test:browser",
     "test:unit": "cross-env SKIP_WEBSERVER=1 playwright test --project=unit",
     "test:unit:node": "npm run test:unit",
     "test:integration": "cross-env SKIP_WEBSERVER=1 playwright test --project=integration",
     "test:integration:node": "npm run test:integration",
+    "pretest:browser": "npm run build:prod",
+    "test:browser": "cross-env SKIP_WEBSERVER=1 playwright test --project=browser",
     "test:playground": "playwright test --project=playground",
     "test:headed": "playwright test --headed",
     "test:ui": "playwright test --ui",
@@ -74,6 +97,6 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/janmbaco/smart-components.git"
+    "url": "https://github.com/janmbaco/smartcomponents.git"
   }
 }

package/dist/behaviors/initializer-factory.d.ts

@@ -1,101 +0,0 @@
-import type { SmartComponent } from '../core/smart-component.js';
-import type { SmartComponentInitializer } from './initializer.base.js';
-import type { IServiceProvider } from '../providers/service-provider.interface.js';
-/**
- * Defines the responsibility of creating initializer instances.
- */
-export interface IInitializerFactory {
-    /**
-     * Creates an initializer instance for the given class.
-     *
-     * @param initializerClass - Initializer class constructor
-     * @returns Fully initialized initializer instance
-     * @throws Error if required dependencies are not available
-     */
-    create<T extends SmartComponent>(initializerClass: new (...args: unknown[]) => SmartComponentInitializer<T>): SmartComponentInitializer<T>;
-    /**
-     * Registers a custom factory function for a specific initializer type.
-     *
-     * @param initializerClass - Initializer class to register
-     * @param factoryFn - Factory function that creates the instance
-     *
-     * @example
-     * ```typescript
-     * factory.registerFactory(CustomInitializer, (resolver) => {
-     *   const http = resolver.get('IHttpService');
-     *   return new CustomInitializer(http);
-     * });
-     * ```
-     */
-    registerFactory<T extends SmartComponent>(initializerClass: new (...args: unknown[]) => SmartComponentInitializer<T>, factoryFn: (serviceProvider: IServiceProvider) => SmartComponentInitializer<T>): void;
-}
-/**
- * Implements the responsibility of creating initializer instances with auto-discovery.
- *
- * @description
- * Centralizes initializer creation logic following the Factory Pattern.
- * Automatically discovers and resolves common framework dependencies.
- * Uses ServiceProvider to resolve dependencies and allows registration of
- * custom factory functions for complex cases.
- *
- * @architecture
- * **Design Decisions:**
- * - Auto-discovery for common dependency patterns (0-4 params)
- * - Strategy pattern via registerFactory for custom cases
- * - Resolves dependencies from ServiceProvider (DIP)
- * - Throws clear errors when dependencies are missing
- * - Allows zero-config for initializers without dependencies
- */
-export declare class InitializerFactory implements IInitializerFactory {
-    private readonly serviceProvider;
-    private readonly factories;
-    /**
-     * Initializes a new instance of InitializerFactory.
-     *
-     * @param serviceProvider - Service provider for dependency resolution
-     * @throws Error if serviceProvider is null or undefined
-     */
-    constructor(serviceProvider: IServiceProvider);
-    registerFactory<T extends SmartComponent>(initializerClass: new (...args: unknown[]) => SmartComponentInitializer<T>, factoryFn: (serviceProvider: IServiceProvider) => SmartComponentInitializer<T>): void;
-    create<T extends SmartComponent>(initializerClass: new (...args: unknown[]) => SmartComponentInitializer<T>): SmartComponentInitializer<T>;
-    /**
-     * Attempts to create initializer with auto-discovered dependencies.
-     *
-     * @description
-     * Tries common dependency patterns for initializers:
-     * - 0 params: new Initializer()
-     * - 1 param: new Initializer(IHttpService | ILogger | custom service)
-     * - 2 params: new Initializer(service1, service2)
-     * - etc.
-     *
-     * Common initializer dependencies:
-     * - HTTP services for data fetching
-     * - Logger services for initialization logging
-     * - Configuration services
-     * - User-defined application services
-     *
-     * @param initializerClass - Initializer class constructor
-     * @returns Instantiated initializer
-     * @throws Error if dependencies cannot be resolved
-     */
-    private createWithAutodiscovery;
-    /**
-     * Attempts to get a service from the provider without throwing.
-     *
-     * @param token - Service token
-     * @returns Service instance or undefined
-     */
-    private tryGet;
-    /**
-     * Applies explicit dependency injection using static inject property.
-     *
-     * @description
-     * If the class defines a static inject property, resolves the declared
-     * dependencies and assigns them to the instance properties.
-     *
-     * @param instance - Initializer instance
-     * @param initializerClass - Initializer class constructor
-     */
-    private applyDependencyInjection;
-}
-//# sourceMappingURL=initializer-factory.d.ts.map

package/dist/behaviors/initializer-factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initializer-factory.d.ts","sourceRoot":"","sources":["../../src/behaviors/initializer-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAGnF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,SAAS,cAAc,EAC7B,gBAAgB,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,yBAAyB,CAAC,CAAC,CAAC,GACzE,yBAAyB,CAAC,CAAC,CAAC,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,CAAC,SAAS,cAAc,EACtC,gBAAgB,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,yBAAyB,CAAC,CAAC,CAAC,EAC1E,SAAS,EAAE,CAAC,eAAe,EAAE,gBAAgB,KAAK,yBAAyB,CAAC,CAAC,CAAC,GAC7E,IAAI,CAAC;CACT;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,kBAAmB,YAAW,mBAAmB;IAShD,OAAO,CAAC,QAAQ,CAAC,eAAe;IAR5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+F;IAEzH;;;;;OAKG;gBAC0B,eAAe,EAAE,gBAAgB;IAM9D,eAAe,CAAC,CAAC,SAAS,cAAc,EACtC,gBAAgB,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,yBAAyB,CAAC,CAAC,CAAC,EAC1E,SAAS,EAAE,CAAC,eAAe,EAAE,gBAAgB,KAAK,yBAAyB,CAAC,CAAC,CAAC,GAC7E,IAAI;IAWP,MAAM,CAAC,CAAC,SAAS,cAAc,EAC7B,gBAAgB,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,yBAAyB,CAAC,CAAC,CAAC,GACzE,yBAAyB,CAAC,CAAC,CAAC;IAuC/B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,uBAAuB;IAwD/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IAWd;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB;CAejC"}