@rindo/core 1.8.12

package/dist/hydrate/platform.mjs

@@ -0,0 +1,347 @@
+import { parsePropertyValue, getValue, setValue, connectedCallback, insertVdomAnnotations } from '@rindo/core/runtime';
+export * from '@rindo/core/runtime';
+
+function proxyHostElement(elm, cmpMeta) {
+    if (typeof elm.componentOnReady !== 'function') {
+        elm.componentOnReady = componentOnReady;
+    }
+    if (typeof elm.forceUpdate !== 'function') {
+        elm.forceUpdate = forceUpdate;
+    }
+    if (cmpMeta.$members$ != null) {
+        const hostRef = getHostRef(elm);
+        const members = Object.entries(cmpMeta.$members$);
+        members.forEach(([memberName, m]) => {
+            const memberFlags = m[0];
+            if (memberFlags & 31) {
+                const attributeName = (m[1] || memberName);
+                const attrValue = elm.getAttribute(attributeName);
+                if (attrValue != null) {
+                    const parsedAttrValue = parsePropertyValue(attrValue, memberFlags);
+                    hostRef.$instanceValues$.set(memberName, parsedAttrValue);
+                }
+                const ownValue = elm[memberName];
+                if (ownValue !== undefined) {
+                    hostRef.$instanceValues$.set(memberName, ownValue);
+                    delete elm[memberName];
+                }
+                Object.defineProperty(elm, memberName, {
+                    get() {
+                        return getValue(this, memberName);
+                    },
+                    set(newValue) {
+                        setValue(this, memberName, newValue, cmpMeta);
+                    },
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+            else if (memberFlags & 64) {
+                Object.defineProperty(elm, memberName, {
+                    value() {
+                        const ref = getHostRef(this);
+                        const args = arguments;
+                        return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName].apply(ref.$lazyInstance$, args)).catch(consoleError);
+                    }
+                });
+            }
+        });
+    }
+}
+function componentOnReady() {
+    return getHostRef(this).$onReadyPromise$;
+}
+function forceUpdate() { }
+
+function hydrateApp(win, opts, results, afterHydrate, resolve) {
+    const connectedElements = new Set();
+    const createdElements = new Set();
+    const orgDocumentCreateElement = win.document.createElement;
+    const orgDocumentCreateElementNS = win.document.createElementNS;
+    const resolved = Promise.resolve();
+    let tmrId;
+    function hydratedComplete() {
+        global.clearTimeout(tmrId);
+        createdElements.clear();
+        connectedElements.clear();
+        try {
+            if (opts.clientHydrateAnnotations) {
+                insertVdomAnnotations(win.document);
+            }
+            win.document.createElement = orgDocumentCreateElement;
+            win.document.createElementNS = orgDocumentCreateElementNS;
+        }
+        catch (e) {
+            renderCatchError(opts, results, e);
+        }
+        afterHydrate(win, opts, results, resolve);
+    }
+    function hydratedError(err) {
+        renderCatchError(opts, results, err);
+        hydratedComplete();
+    }
+    function timeoutExceeded() {
+        hydratedError(`Hydrate exceeded timeout`);
+    }
+    try {
+        function patchedConnectedCallback() {
+            return connectElement(this);
+        }
+        function patchElement(elm) {
+            if (isValidComponent(elm, opts)) {
+                const hostRef = getHostRef(elm);
+                if (!hostRef) {
+                    const Cstr = getComponent(elm.nodeName.toLowerCase());
+                    if (Cstr != null && Cstr.cmpMeta != null) {
+                        createdElements.add(elm);
+                        elm.connectedCallback = patchedConnectedCallback;
+                        registerHost(elm);
+                        proxyHostElement(elm, Cstr.cmpMeta);
+                    }
+                }
+            }
+        }
+        function patchChild(elm) {
+            if (elm != null && elm.nodeType === 1) {
+                patchElement(elm);
+                const children = elm.children;
+                for (let i = 0, ii = children.length; i < ii; i++) {
+                    patchChild(children[i]);
+                }
+            }
+        }
+        function connectElement(elm) {
+            createdElements.delete(elm);
+            if (isValidComponent(elm, opts) && results.hydratedCount < opts.maxHydrateCount) {
+                if (!connectedElements.has(elm) && shouldHydrate(elm)) {
+                    connectedElements.add(elm);
+                    return hydrateComponent(win, results, elm.nodeName, elm);
+                }
+            }
+            return resolved;
+        }
+        function waitLoop() {
+            const toConnect = Array.from(createdElements).filter(elm => elm.parentElement);
+            if (toConnect.length > 0) {
+                return Promise.all(toConnect.map(connectElement))
+                    .then(waitLoop);
+            }
+            return resolved;
+        }
+        win.document.createElement = function patchedCreateElement(tagName) {
+            const elm = orgDocumentCreateElement.call(win.document, tagName);
+            patchElement(elm);
+            return elm;
+        };
+        win.document.createElementNS = function patchedCreateElement(namespaceURI, tagName) {
+            const elm = orgDocumentCreateElementNS.call(win.document, namespaceURI, tagName);
+            patchElement(elm);
+            return elm;
+        };
+        tmrId = global.setTimeout(timeoutExceeded, opts.timeout);
+        plt.$resourcesUrl$ = new URL(opts.resourcesUrl || './', doc.baseURI).href;
+        patchChild(win.document.body);
+        waitLoop()
+            .then(hydratedComplete)
+            .catch(hydratedError);
+    }
+    catch (e) {
+        hydratedError(e);
+    }
+}
+async function hydrateComponent(win, results, tagName, elm) {
+    tagName = tagName.toLowerCase();
+    const Cstr = getComponent(tagName);
+    if (Cstr != null) {
+        const cmpMeta = Cstr.cmpMeta;
+        if (cmpMeta != null) {
+            try {
+                connectedCallback(elm, cmpMeta);
+                await elm.componentOnReady();
+                results.hydratedCount++;
+                const ref = getHostRef(elm);
+                const modeName = !ref.$modeName$ ? '$' : ref.$modeName$;
+                if (!results.components.some(c => c.tag === tagName && c.mode === modeName)) {
+                    results.components.push({
+                        tag: tagName,
+                        mode: modeName,
+                        count: 0,
+                        depth: -1,
+                    });
+                }
+            }
+            catch (e) {
+                win.console.error(e);
+            }
+        }
+    }
+}
+function isValidComponent(elm, opts) {
+    if (elm != null && elm.nodeType === 1) {
+        const tagName = elm.nodeName;
+        if (typeof tagName === 'string' && tagName.includes('-')) {
+            if (opts.excludeComponents.includes(tagName.toLowerCase())) {
+                return false;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+function shouldHydrate(elm) {
+    if (elm.nodeType === 9) {
+        return true;
+    }
+    if (NO_HYDRATE_TAGS.has(elm.nodeName)) {
+        return false;
+    }
+    if (elm.hasAttribute('no-prerender')) {
+        return false;
+    }
+    const parentNode = elm.parentNode;
+    if (parentNode == null) {
+        return true;
+    }
+    return shouldHydrate(parentNode);
+}
+const NO_HYDRATE_TAGS = new Set([
+    'CODE',
+    'HEAD',
+    'IFRAME',
+    'INPUT',
+    'OBJECT',
+    'OUTPUT',
+    'NOSCRIPT',
+    'PRE',
+    'SCRIPT',
+    'SELECT',
+    'STYLE',
+    'TEMPLATE',
+    'TEXTAREA'
+]);
+function renderCatchError(opts, results, err) {
+    const diagnostic = {
+        level: 'error',
+        type: 'build',
+        header: 'Hydrate Error',
+        messageText: '',
+        relFilePath: null,
+        absFilePath: null,
+        lines: []
+    };
+    if (opts.url) {
+        try {
+            const u = new URL(opts.url);
+            if (u.pathname !== '/') {
+                diagnostic.header += ': ' + u.pathname;
+            }
+        }
+        catch (e) { }
+    }
+    if (err != null) {
+        if (err.stack != null) {
+            diagnostic.messageText = err.stack.toString();
+        }
+        else if (err.message != null) {
+            diagnostic.messageText = err.message.toString();
+        }
+        else {
+            diagnostic.messageText = err.toString();
+        }
+    }
+    results.diagnostics.push(diagnostic);
+}
+
+const cstrs = new Map();
+const loadModule = (cmpMeta, _hostRef, _hmrVersionId) => {
+    return cstrs.get(cmpMeta.$tagName$);
+};
+const getComponent = (tagName) => {
+    return cstrs.get(tagName);
+};
+const isMemberInElement = (elm, memberName) => {
+    if (elm != null) {
+        if (memberName in elm) {
+            return true;
+        }
+        const nodeName = elm.nodeName;
+        if (nodeName) {
+            const hostRef = getComponent(nodeName.toLowerCase());
+            if (hostRef != null && hostRef.cmpMeta != null && hostRef.cmpMeta.$members$ != null) {
+                return memberName in hostRef.cmpMeta.$members$;
+            }
+        }
+    }
+    return false;
+};
+const registerComponents = (Cstrs) => {
+    Cstrs.forEach(Cstr => {
+        cstrs.set(Cstr.cmpMeta.$tagName$, Cstr);
+    });
+};
+const win = window;
+const doc = win.document;
+const readTask = (cb) => {
+    process.nextTick(() => {
+        try {
+            cb();
+        }
+        catch (e) {
+            consoleError(e);
+        }
+    });
+};
+const writeTask = (cb) => {
+    process.nextTick(() => {
+        try {
+            cb();
+        }
+        catch (e) {
+            consoleError(e);
+        }
+    });
+};
+const nextTick = (cb) => Promise.resolve().then(cb);
+const consoleError = (e) => {
+    if (e != null) {
+        console.error(e.stack || e.message || e);
+    }
+};
+const consoleDevError = (..._) => { };
+const consoleDevWarn = (..._) => { };
+const consoleDevInfo = (..._) => { };
+const Context = {};
+const plt = {
+    $flags$: 0,
+    $resourcesUrl$: '',
+    jmp: (h) => h(),
+    raf: (h) => requestAnimationFrame(h),
+    ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
+    rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
+};
+const supportsShadowDom = false;
+const supportsListenerOptions = false;
+const supportsConstructibleStylesheets = false;
+const hostRefs = new WeakMap();
+const getHostRef = (ref) => hostRefs.get(ref);
+const registerInstance = (lazyInstance, hostRef) => hostRefs.set(hostRef.$lazyInstance$ = lazyInstance, hostRef);
+const registerHost = (elm) => {
+    const hostRef = {
+        $flags$: 0,
+        $hostElement$: elm,
+        $instanceValues$: new Map(),
+        $renderCount$: 0
+    };
+    hostRef.$onInstancePromise$ = new Promise(r => hostRef.$onInstanceResolve$ = r);
+    hostRef.$onReadyPromise$ = new Promise(r => hostRef.$onReadyResolve$ = r);
+    elm['s-p'] = [];
+    elm['s-rc'] = [];
+    return hostRefs.set(elm, hostRef);
+};
+const Build = {
+    isDev: false,
+    isBrowser: false
+};
+const styles = new Map();
+
+export { Build, Context, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, doc, getComponent, getHostRef, hydrateApp, isMemberInElement, loadModule, nextTick, plt, readTask, registerComponents, registerHost, registerInstance, styles, supportsConstructibleStylesheets, supportsListenerOptions, supportsShadowDom, win, writeTask };

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import * as d from './declarations';
+export { ComponentDidLoad, ComponentDidUnload, ComponentDidUpdate, ComponentWillLoad, ComponentWillUpdate, ComponentInterface, RindoConfig as Config, EventEmitter, FunctionalComponent, QueueApi, JSX } from './declarations';
+/**
+ * Build
+ */
+export declare const Build: d.UserBuildConditionals;
+/**
+ * Component
+ */
+export declare const Component: d.ComponentDecorator;
+/**
+ * Element
+ */
+export declare const Element: d.ElementDecorator;
+/**
+ * Event
+ */
+export declare const Event: d.EventDecorator;
+/**
+ * Listen
+ */
+export declare const Listen: d.ListenDecorator;
+/**
+ * Method
+ */
+export declare const Method: d.MethodDecorator;
+/**
+ * Prop
+ */
+export declare const Prop: d.PropDecorator;
+/**
+ * State
+ */
+export declare const State: d.StateDecorator;
+/**
+ * Watch
+ */
+export declare const Watch: d.WatchDecorator;
+/**
+ * setMode
+ */
+export declare const setMode: (handler: ((elm: HTMLElement) => string | undefined | null)) => void;
+/**
+ * getMode
+ */
+export declare function getMode<T = (string | undefined)>(ref: any): T;
+/**
+ * getAssetPath
+ */
+export declare function getAssetPath(path: string): string;
+/**
+ * getElement
+ */
+export declare function getElement(ref: any): d.HTMLRindoElement;
+/**
+ * writeTask
+ */
+export declare function writeTask(task: d.RafCallback): void;
+/**
+ * readTask
+ */
+export declare function readTask(task: d.RafCallback): void;
+/**
+ * forceUpdate
+ */
+export declare function forceUpdate(ref: any): void;
+/**
+ * Host
+ */
+interface HostAttributes {
+    class?: string | {
+        [className: string]: boolean;
+    };
+    style?: {
+        [key: string]: string | undefined;
+    };
+    ref?: (el: HTMLElement | null) => void;
+    [prop: string]: any;
+}
+export declare const Host: d.FunctionalComponent<HostAttributes>;
+/**
+ * The "h" namespace is used to import JSX types for elements and attributes.
+ * It is imported in order to avoid conflicting global JSX issues.
+ */
+export declare namespace h {
+    function h(sel: any): d.VNode;
+    function h(sel: Node, data: d.VNodeData): d.VNode;
+    function h(sel: any, data: d.VNodeData): d.VNode;
+    function h(sel: any, text: string): d.VNode;
+    function h(sel: any, children: Array<d.VNode | undefined | null>): d.VNode;
+    function h(sel: any, data: d.VNodeData, text: string): d.VNode;
+    function h(sel: any, data: d.VNodeData, children: Array<d.VNode | undefined | null>): d.VNode;
+    function h(sel: any, data: d.VNodeData, children: d.VNode): d.VNode;
+    namespace JSX {
+        interface IntrinsicElements extends d.JSX.IntrinsicElements, d.JSXBase.IntrinsicElements {
+            [tagName: string]: any;
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1 @@
+exports.h = function() {};