be-hive 0.0.201 → 0.0.203

package/be-hive.ts

@@ -0,0 +1,134 @@
+import {Synthesizer} from 'mount-observer/Synthesizer.js';
+import { AddMountEventListener, MountInit, MOSE, MOSEAddedProps} from './ts-refs/mount-observer/types';
+export {EMC} from './ts-refs/trans-render/be/types';
+export {MountObserver, MOSE} from 'mount-observer/MountObserver.js';
+import {AttrMapPoint, EMC} from './ts-refs/trans-render/be/types';
+import { MountEvent } from 'mount-observer/MountObserver';
+import 'be-enhanced/beEnhanced.js';
+import { BeEnhanced, Enhancers } from 'be-enhanced/beEnhanced.js';
+
+export const defaultObsAttrs: Partial<EMC> = {
+    hasRootIn: [
+        {
+            start: '',
+            context: 'BuiltIn'
+        },
+        {
+            start: 'enh',
+            context: 'Both'
+        },
+        {
+            start: 'data-enh',
+            context: 'Both'
+        },
+
+
+
+    ],
+    base: '',
+    preBaseDelimiter: '-',
+    preBranchDelimiter: '-',
+    preLeafDelimiter: '--',
+    enhancedElementMatches: '*',
+    enhancedElementInstanceOf: [Element]
+};
+
+export function seed(emc: EMC){
+    try{
+        Enhancers.define(emc);
+    }catch(e){}
+    
+    const mose = document.createElement('script') as MOSE<EMC>;
+    const id = `be-hive.${emc.base}`;
+    mose.id = emc.id = id;
+    mose.synConfig = emc;
+    return mose;
+}
+
+export class BeHive extends Synthesizer {
+    override activate(mose: MOSE<any>) {
+        if(!this.checkIfAllowed(mose)) return;
+        const {synConfig} = mose as MOSEAddedProps<any>;
+        const mergeWithDefaults = {...defaultObsAttrs, ...synConfig} as EMC;
+        //TODO allow for programmatic adjustments in load event
+        //this.dispatchEvent(new RegistryEventImpl(mergeWithDefaults));
+        const {
+            base, block, branches, enhancedElementInstanceOf,
+            enhancedElementMatches, hostInstanceOf, hostMatches,
+            leaves, preBaseDelimiter, preBranchDelimiter, importEnh,
+            preLeafDelimiter, hasRootIn, map, osotas
+            
+        } = mergeWithDefaults;
+        const mi: MountInit = {
+            on: enhancedElementMatches,
+            whereInstanceOf: enhancedElementInstanceOf,
+            whereAttr: {
+                hasRootIn,
+                hasBase: [preBaseDelimiter!, base!],
+                
+            },
+            observedAttrsWhenMounted: osotas,
+        };
+        if(branches !== undefined){
+            mi.whereAttr!.hasBranchIn = [preBaseDelimiter!, branches];
+        }
+        if(leaves !== undefined){
+            throw 'NI';
+        }
+        mose.init = mi;
+        super.activate(mose);
+        const mo = mose.observer;
+        (mo as any as AddMountEventListener).addEventListener('mount', async e => {
+            const {mountedElement} = (e as MountEvent);
+            const {beEnhanced} : {beEnhanced: BeEnhanced} = (<any>mountedElement);
+            const enhancementConstructor = await importEnh!();
+            const {enhPropKey} = mergeWithDefaults;
+            const initialPropValues = (<any>beEnhanced)[enhPropKey!] || {};
+            if(initialPropValues instanceof enhancementConstructor) return;
+            const enhancementInstance =  new enhancementConstructor();
+            (<any>beEnhanced)[enhPropKey!] = enhancementInstance;
+            const initialAttrInfo = mo.readAttrs(mountedElement);
+            if(map !== undefined){
+                for(const attr of initialAttrInfo){
+                    if(attr.isSOfTAttr) continue;
+                    const leafIdx = 0;
+                    const {parts, newValue} = attr;
+                    if(newValue === null) continue;
+                    const {branchIdx} = parts!;
+                    const key = `${branchIdx}.${leafIdx}`;
+                    const prop = (<any>map)[key] as AttrMapPoint;
+                    if(prop === undefined) continue;
+                    switch(typeof prop){
+                        case 'string':
+                            if(initialPropValues[prop] !== undefined) continue;
+                            initialPropValues[prop] = newValue;
+                            break;
+                        case 'object':
+                            const {prsObj} = await import ('./prsObj.js');
+                            await prsObj(prop, newValue, initialPropValues, attr);
+                            break;
+                        default:
+                            throw 'NI';
+                    }
+                    
+                }
+            }
+            if(osotas !== undefined){
+                for(const attr of initialAttrInfo){
+                    if(!attr.isSOfTAttr) continue;
+                    const {mapsTo, newValue} = attr;
+                    initialPropValues[mapsTo!] = newValue;
+                }
+            }
+            enhancementInstance.attach(mountedElement, {
+                initialAttrInfo,
+                initialPropValues,
+                mountCnfg: mergeWithDefaults
+            });
+        });
+    }
+}
+
+if(customElements.get('be-hive') === undefined){
+    customElements.define('be-hive', BeHive);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "be-hive",
-  "version": "0.0.201",
+  "version": "0.0.203",
   "keywords": [
     "web-components",
     "web-component",
@@ -11,26 +11,31 @@
   "main": "be-hive.js",
   "module": "be-hive.js",
   "exports": {
-    ".": "./be-hive.js",
-    "./be-hive.js": "./be-hive.js",
-    "./register.js": "./register.js",
-    "./beatify.js": "./beatify.js",
-    "./getLocalName.js": "./getLocalName.js",
-    "./toTempl.js": "./toTempl.js"
+    ".": {
+      "default": "./be-hive.js",
+      "types": "./be-hive.ts"
+    },
+    "./be-hive.js": {
+      "default": "./be-hive.js",
+      "types": "./be-hive.ts"
+    },
+    "./prsObj.js": {
+      "default": "./prsObj.js",
+      "types": "./prsObj.ts"
+    }
   },
   "files": [
     "*.js",
-    "types.d.ts"
+    "*.ts"
   ],
-  "types": "types.d.ts",
   "scripts": {
     "serve": "node node_modules/may-it-serve/serve.js",
     "update": "ncu -u && npm install"
   },
   "dependencies": {
-    "be-enhanced": "0.0.131",
-    "mount-observer": "0.0.31",
-    "trans-render": "0.0.821"
+    "be-enhanced": "0.0.134",
+    "mount-observer": "0.0.34",
+    "trans-render": "0.0.826"
   },
   "devDependencies": {
     "may-it-serve": "0.0.8"

package/prsObj.ts

@@ -0,0 +1,84 @@
+import {AttrMapConfig} from './ts-refs/trans-render/be/types';
+import { AttrChangeInfo } from './ts-refs/mount-observer/types';
+import { IObject$tring } from './ts-refs/trans-render/types';
+
+export async function prsObj(prop: AttrMapConfig, newValue: string, initialPropValues: any, attr: AttrChangeInfo){
+    const {instanceOf, mapsTo, valIfFalsy} = prop;
+    let valToSet = newValue;
+    if(valIfFalsy !== undefined && !newValue && mapsTo){
+        if(mapsTo === '.'){
+            if(typeof valIfFalsy === 'object'){
+                Object.assign(initialPropValues, valIfFalsy);
+            }else {
+                throw 'NI';
+            }
+            
+        }else{
+            initialPropValues[mapsTo] = valIfFalsy;
+        }
+        
+    }else{
+        switch(instanceOf){
+            case 'Object':
+                try{
+                    valToSet = JSON.parse(newValue);
+                }catch(e){
+                    throw {err: 400, attr, newValue};
+                }
+                if(mapsTo === undefined) throw 400;
+                if(mapsTo === '.'){
+                    Object.assign(initialPropValues, valToSet);
+                }else{
+                    initialPropValues[mapsTo] = valToSet;
+                }
+                break;
+            case 'String':
+                initialPropValues[mapsTo!] = valToSet;
+                break;
+            case 'Boolean':
+                initialPropValues[mapsTo!] = valToSet !== null;
+                break;
+            case 'Number':
+                initialPropValues[mapsTo!] = Number(valToSet);
+                break;
+            case 'DSSArray':
+            case 'Object$tring':
+            case 'Object$entences':
+                const {strValMapsTo, objValMapsTo, arrValMapsTo} = prop;
+                let parsedObj : IObject$tring | undefined;
+                switch(instanceOf){
+                    case 'Object$tring':
+                        const {Object$tring} = await import('trans-render/Object$tring.js');
+                        parsedObj = new Object$tring(newValue);
+                        break;
+                    case 'Object$entences':
+                        const {Object$entences} = await import('trans-render/Object$entences.js');
+                        parsedObj = new Object$entences(newValue, prop);
+                        break;
+                    case 'DSSArray':
+                        const {DSSArray} = await import('trans-render/DSSArray.js');
+                        parsedObj = new DSSArray(newValue);
+                        break;
+
+                }
+                await parsedObj.parse();
+                
+                if(parsedObj.strVal && strValMapsTo !== undefined){
+                    initialPropValues[strValMapsTo] = parsedObj.strVal;
+                }
+                if(parsedObj.objVal && objValMapsTo !== undefined){
+                    if(objValMapsTo === '.'){
+                        Object.assign(initialPropValues, parsedObj.objVal);
+                    }else{
+                        initialPropValues[objValMapsTo] = parsedObj.objVal;
+                    }
+                }else if(parsedObj.arrVal && arrValMapsTo !== undefined){
+                    initialPropValues[arrValMapsTo] = parsedObj.arrVal;
+                }
+                break;
+            default:
+                throw 'NI';
+        }
+    }
+
+}