mount-observer 0.0.103 → 0.0.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mount-observer",
-  "version": "0.0.103",
+  "version": "0.0.104",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",

package/refid/itemprops.js

@@ -1,30 +1,60 @@
 "use strict";
-function getScopedChildren(element, lookup) {
-    if (lookup === undefined)
-        lookup = {};
+function getFirst(element, prop) {
     for (const child of element.children) {
         const itemprop = child.getAttribute('itemprop');
-        if (itemprop !== null) {
-            const lookupItemProp = lookup[itemprop];
-            if (lookupItemProp) {
-                if (!Array.isArray(lookupItemProp)) {
-                    lookup[itemprop] = [lookupItemProp];
-                }
-                lookup[itemprop].push(child);
-            }
-            else {
-                lookup[itemprop] = child;
-            }
+        if (itemprop === prop) {
+            return child;
         }
         if (!child.hasAttribute('itemscope')) {
-            getScopedChildren(child, lookup);
+            const found = getFirst(child, prop);
+            if (found)
+                return found;
         }
     }
+    return null;
 }
+const proxies = new WeakMap();
+const refLookup = new WeakMap();
 Object.defineProperty(Element.prototype, 'itemprops', {
     get() {
-        if (!this.hasAttribute('itemscope'))
-            return undefined;
-        return getScopedChildren(this);
+        if (!proxies.has(this)) {
+            const handler = {
+                get(target, prop) {
+                    let lookup;
+                    if (refLookup.has(target)) {
+                        lookup = refLookup.get(target);
+                    }
+                    else {
+                        lookup = new Map();
+                        refLookup.set(target, lookup);
+                    }
+                    if (lookup.has(prop)) {
+                        return lookup.get(prop);
+                    }
+                    else {
+                        const propManager = new ItempropManager(target, prop);
+                        lookup.set(prop, propManager);
+                        return propManager;
+                    }
+                },
+            };
+            proxies.set(this, new Proxy(this, handler));
+        }
+        return refLookup.get(this);
     }
 });
+class ItempropManager extends EventTarget {
+    #el;
+    #prop;
+    constructor(el, prop) {
+        super();
+        this.#el = new WeakRef(el);
+        this.#prop = prop;
+    }
+    get first() {
+        const el = this.#el.deref();
+        if (el === undefined)
+            return null;
+        return getFirst(el, this.#prop);
+    }
+}

package/refid/itemprops.ts

@@ -1,27 +1,67 @@
-function getScopedChildren(element: Element, lookup?: {[key: string]: Element | Element[]}){
-    if(lookup === undefined) lookup = {};
+function getFirst(element: Element, prop: string): Element | null {
     for(const child of element.children){
         const itemprop = child.getAttribute('itemprop');
-        if(itemprop !== null){
-            const lookupItemProp = lookup[itemprop]
-            if(lookupItemProp){
-                if(!Array.isArray(lookupItemProp)){
-                    lookup[itemprop] = [lookupItemProp];
-                }
-                (lookup[itemprop] as Element[]).push(child);
-            }else{
-                lookup[itemprop] = child;
-            }
+        if(itemprop === prop){
+            return child;
         }
         if(!child.hasAttribute('itemscope')){
-            getScopedChildren(child, lookup);
+            const found = getFirst(child, prop);
+            if(found) return found;
         }
     }
+    return null;
 }
+const proxies = new WeakMap<Element, ProxyConstructor>();
+const refLookup = new WeakMap<Element, PropManagerLookup>();
 Object.defineProperty(Element.prototype, 'itemprops', {
+
     get(){
-        if(!this.hasAttribute('itemscope')) return undefined;
-        return getScopedChildren(this); 
+        if(!proxies.has(this)){
+            const handler = {
+                get(target: Element, prop: string) {
+                    let lookup: PropManagerLookup;
+                    if(refLookup.has(target)){
+                        lookup = refLookup.get(target)!;
+                    }else{
+                        lookup = new Map<Prop, ItempropManager>();
+                        refLookup.set(target, lookup);
+                    }
+                    if(lookup.has(prop)){
+                        return lookup.get(prop);
+                    }else{
+                        const propManager = new ItempropManager(target, prop as string);
+                        lookup.set(prop, propManager);
+                        return propManager;
+                    }
+                },
+                
+            };
+            proxies.set(this, new Proxy(this, handler));
+        }
+
+
+        return refLookup.get(this); 
     }
 });
 
+type Prop = string;
+
+type PropManagerLookup = Map<Prop, ItempropManager>;
+
+class ItempropManager extends EventTarget {
+    #el: WeakRef<Element>;
+    #prop: Prop;
+    constructor(el: Element, prop: Prop){
+        super();
+        this.#el = new WeakRef(el);
+        this.#prop = prop;
+    }
+
+    get first(){
+        const el = this.#el.deref();
+        if(el === undefined) return null;
+        return getFirst(el, this.#prop);
+    }
+    
+}
+