pawa-ssr 1.4.0 → 1.4.2

package/index.d.ts

@@ -0,0 +1,66 @@
+import { HTMLElement } from 'linkedom';
+
+/**
+ * Core rendering function that processes PawaElements/HTMLElements and writes to a stream.
+ */
+export function render(el: any, contexts?: object, stream?: (s: string) => void): Promise<void>;
+
+export interface StartAppResult {
+  element: any;
+  toString: () => Promise<string>;
+  head: string;
+}
+
+/**
+ * Initializes and renders the application for standard SSR.
+ */
+export function startApp(
+  html: string,
+  context?: object,
+  development?: boolean
+): Promise<StartAppResult>;
+
+/**
+ * Initializes and renders the application using Node.js streams for performance and Suspense support.
+ */
+export function startStreamApp(
+  html: string,
+  context: object,
+  stream: (s: string) => void,
+  options: { templateStart: string; templateEnd: string }
+): Promise<void>;
+
+/**
+ * Adds custom directives that should be treated as part of the PawaJS directive set.
+ */
+export function addToPartlyDirective(...partly: string[]): void;
+
+/**
+ * Returns an array of all reserved server attributes.
+ */
+export function getAllServerAttrArray(): string[];
+
+/**
+ * Returns the set of registered Pawa attributes.
+ */
+export function getPawaAttributes(): Set<string>;
+
+/**
+ * Checks if the application is running in development mode.
+ */
+export function getDevelopment(): boolean | undefined;
+
+/**
+ * Configures the server-side hooks for PawaJS.
+ */
+export const pawaForServer: (config: {
+  useContext: (context: { id: string }) => any;
+  useInnerContext: () => any;
+  useInsert: (obj?: object) => void;
+  setContext: () => { id: string; setValue: (context: object) => void };
+  $state: <T>(initialValue: T | (() => T)) => T;
+  accessChild: () => void;
+  useServer: () => { setServerData: (data: object) => void, getServerData: () => object } | undefined;
+  useAsync: () => { $async: <R>(callback: () => R) => R, onSuspense: (html: string) => void } | undefined;
+  forwardProps: (props?: object) => void;
+}) => void;

package/index.js

@@ -243,92 +243,6 @@ const setPawaAttribute=(...attr)=>{
 }
 setPawaAttribute('if','else','else-if','for-each','case','switch','s-default','for-key','key')
 export const getPawaAttributes=()=>pawaAttributes
-/**
- * @typedef {{startsWith:string,fullName:string,plugin:(el:HTMLElement | PawaElement,attr:object)=>void}} AttriPlugin
- */
-/**
- * @typedef {{
- * attribute?:{register:Array<AttriPlugin>},
- * component?:{
- * beforeCall?:(stateContext:PawaComponent,app:object)=>void,
- * afterCall?:(stateContext:PawaComponent,el:HTMLElement)=>void
- * },
- * renderSystem?:{
- *  beforePawa?:(el:HTMLElement,context:object)=>void,
- *  afterPawa?:(el:PawaElement)=>void,
- *  beforeChildRender?:(el:PawaElement)=>void
- * }
- * }} PluginObject
- */
-/**
- * @param {Array<()=>PluginObject>} func
- */
-export const PluginSystem=(...func)=>{
-  func.forEach(fn=>{ 
-    /**
-     * @type {PluginObject}
-     */
-    if (typeof fn !== 'function') {
-      console.warn('plugin must be a function that returns the plugin objects')
-      return
-    }
-    const getPlugin=fn()
-    // attributes plugin or extension
-    
-    if (getPlugin?.attribute) {
-      getPlugin.attribute.register.forEach(attrPlugins =>{
-        if (attrPlugins.fullName && attrPlugins.startsWith) {
-          console.warn('Either Plugins FullName or startsWith. you are not required to use to of does plugin registers at this same entry.')
-          return
-        }
-        if (attrPlugins?.fullName) {
-          if (pawaAttributes.has(attrPlugins.fullName) ) {
-            console.warn(`attribute plugin already exist ${attrPlugins.fullName}`)
-            return
-          }
-          pawaAttributes.add(attrPlugins.fullName)
-        fullNamePlugin.add(attrPlugins.fullName)
-        externalPlugin[attrPlugins.fullName]=attrPlugins?.plugin
-        }else if (attrPlugins?.startsWith) {
-          if (pawaAttributes.has(attrPlugins.startsWith) ) {
-          console.warn(`attribute plugin already exist ${attrPlugins.startsWith}`)
-          return
-        }
-        pawaAttributes.add(attrPlugins.startsWith)
-        startsWithSet.add(attrPlugins.startsWith)
-        externalPlugin[attrPlugins.startsWith]=attrPlugins?.plugin
-        }
-      })
-    }
-    if (getPlugin?.component) {
-      if (getPlugin.component?.beforeCall && typeof getPlugin.component?.beforeCall === 'function') {
-        compoBeforeCall.add(getPlugin.component.beforeCall)
-      }
-      if (getPlugin.component?.afterCall && typeof getPlugin.component?.afterCall === 'function') {
-        compoAfterCall.add(getPlugin.component.afterCall)
-      }
-    }
-    if (getPlugin?.renderSystem) {
-      if (getPlugin.renderSystem?.beforePawa && typeof getPlugin.renderSystem?.beforePawa === 'function') {
-        renderBeforePawa.add(getPlugin.renderSystem?.beforePawa)
-      }
-      if (getPlugin.renderSystem?.afterPawa && typeof getPlugin.renderSystem?.afterPawa === 'function') {
-        renderAfterPawa.add(getPlugin.renderSystem?.afterPawa)
-      }
-      if (getPlugin.renderSystem?.beforeChildRender && typeof getPlugin.renderSystem?.beforeChildRender === 'function') {
-        renderBeforeChild.add(getPlugin.renderSystem?.beforeChildRender)
-      }
-    }
-  })
-}
-
-export const useValidateComponent=(component,object)=>{
-  if (typeof component === 'function' ) {
-    if(component.name){
-      component.validateProps=object
-    }
-  }
-}
 
 /**
  * @typedef {{
@@ -724,10 +638,12 @@ appContext.component._prop={children,...el._props,...slots}
           if (getChildren.hasAttribute(attr.name)) {
             let attrName=getChildren.getAttribute(attr.name)
             attrName=attr.value +' '+attrName
+            
             getChildren.setAttribute(attr.name, attrName)
           }else{
             getChildren.setAttribute(attr.name, attr.value)
           }
+          // console.log(attr.name,attr.value);
         })      
       }
     }   

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pawa-ssr",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "type": "module",
   "description": "pawajs ssr libary",
   "main": "index.js",
@@ -24,7 +24,9 @@
   },
   "homepage": "https://github.com/Allisboy/pawajs-ssr#readme",
   "dependencies": {
-    "linkedom": "^0.18.11",
+    "linkedom": "^0.18.11"
+  },
+  "peerDependencies": {
     "pawajs": "^2.0.0"
   }
 }

package/pawaElement.js

@@ -220,13 +220,15 @@ class PawaElement {
                  hydatename=':'+name
                 }
                 this._hydrateProps[hydatename]=attr.value
+                let value=attr.value
+                let context=this._context
+                const main={...context}
                 const setProps=()=>{
-                  let value=attr.value
                  if (value.includes('@{')) {
                    const regex = /@{([^}]*)}/g;
                  value = value.replace(regex, (match, expression) => {
                      
-                         const res = this.evaluateExpr(expression,this._context,`evaluating props with template operators at ${attr.name} - ${attr.value} : ${this._template}`)
+                         const res = this.evaluateExpr(expression,{...main},`evaluating props with template operators at ${attr.name} - ${attr.value} : ${this._template}`)
                          return res
                      
                  });
@@ -284,16 +286,11 @@ class PawaElement {
 evaluateExpr(expr, context = {},error){
   try {
     const keys = Object.keys(context);
-    // Create a cache key based on the expression and the available context keys
-    // We sort keys to ensure consistent cache hits regardless of key order
-    const cacheKey = expr + '|||' + keys.sort().join(',');
-
-    let func = expressionCache.get(cacheKey);
+    let func 
     if (!func) {
       func = new Function(...keys, `
         const require=null
         return ${expr}`);
-      expressionCache.set(cacheKey, func);
     }
 
     const values = keys.map((key) => context[key]);

package/test/App.js

@@ -1,4 +1,8 @@
+import { useInnerContext } from "pawajs"
+
 export const App=({children})=>{
+    const context=useInnerContext()
+    console.log(context)
     return `<div class="p-4">
         <h1 class="text-2xl font-bold mb-4">Hello, World!</h1>
         <p class="text-gray-700">This is a test component for PawaJS.</p>

package/test/index.js

@@ -1,10 +1,18 @@
 import {useValidateComponent, RegisterComponent,useContext,useInsert,setContext,forwardProps} from 'pawajs'
-import {startApp} from '../index.js'
+import {startApp,startStreamApp} from '../index.js'
  RegisterComponent.lazy(
   'App',()=>import('./App.js'),
   'Check',()=>import('./check.js'),
   'Check2',()=>import('./check.js'),
 )
+const Dtext=({})=>{
+  const classActive='class y-p'
+  useInsert({classActive})
+  return`
+  <div class="@{classActive}"></div>
+  `
+}
+__pawaDev.tool=true
 const Dinput=({className,...props})=>{
   forwardProps(props)
   const classActive=()=>[className?.() || '','py-2 text-blue'].join(' ')
@@ -13,12 +21,13 @@ const Dinput=({className,...props})=>{
   <input class="@{classActive()}" -- />
   `
 }
-RegisterComponent(Dinput)
+RegisterComponent(Dtext,Dinput)
 const app=`
 <div>
-  <dinput type="file" aschild>
-    <div>input</div>
-  </dinput>
+
+  <d-text aschild>
+  <dinput type="file" ></dinput>
+  </d-text>
   <app>
     <check></check>
     <check-2></check-2>
@@ -28,5 +37,11 @@ const app=`
   </div>
 </div>
 `
-const {toString}=await startApp(app)
-console.log(await toString());
+// const {toString}=await startApp(app)
+// console.log(await toString());
+let strings=''
+const stream=(string)=>strings+=string
+
+await startStreamApp(app,{url:'/'},stream,{templateEnd:'</body>',templateStart:'<body>'})
+console.log(strings);
+