godown 1.1.5 → 1.1.6

package/view/route-view.d.ts

@@ -1,58 +1,58 @@
-import type { TemplateResult } from "lit";
-import { LitElement } from "../deps.js";
-export declare class RouteView extends LitElement {
-    _routes: Array<{
-        path: string;
-        [key: string]: any;
-    }>;
-    params: Record<string, string>;
-    static: boolean;
-    type: "united" | "child" | "slotted" | "field";
-    baseURL: string;
-    path: string;
-    override: boolean;
-    compoent: any;
-    set routes(v: {
-        [key: string]: any;
-        path: string;
-    }[]);
-    get routes(): {
-        [key: string]: any;
-        path: string;
-    }[];
-    static styles: import("lit").CSSResult;
-    render(): TemplateResult<2 | 1>;
-    useRouter(): {
-        path: string;
-        params: Record<string, string>;
-    };
-    connectedCallback(): void;
-    render_united(): TemplateResult<2 | 1>;
-    render_slotted(): TemplateResult<2 | 1>;
-    render_field(): TemplateResult<2 | 1>;
-    fieldComponent(usedRouteTemplate: string): null | TemplateResult;
-    slottedCompoent(usedRouteTemplate: string, ObjectArrayIncludePath: Array<{
-        path: string;
-        slotElement?: string;
-        [key: string]: any;
-    }>): null | TemplateResult;
-    static sortRoutesPaths(ObjectArrayIncludePath: Array<{
-        path: string;
-        [key: string]: any;
-    }>): Array<{
-        path: string;
-    }>;
-    static useWhichRoute(ObjectArrayIncludePath: Array<{
-        path: string;
-        [key: string]: any;
-    }>, path: string, baseURL?: string): string;
-    static parseRouterParams(routeTemplate: string, originpath: string): Record<string, string>;
-    static updateAll(): void;
-}
-export default RouteView;
-declare global {
-    interface HTMLElementTagNameMap {
-        "route-view": RouteView;
-    }
-}
+import type { TemplateResult } from "lit";
+import { LitElement } from "../deps.js";
+export declare class RouteView extends LitElement {
+    _routes: Array<{
+        path: string;
+        [key: string]: any;
+    }>;
+    params: Record<string, string>;
+    static: boolean;
+    type: "united" | "child" | "slotted" | "field";
+    baseURL: string;
+    path: string;
+    override: boolean;
+    compoent: any;
+    set routes(v: {
+        [key: string]: any;
+        path: string;
+    }[]);
+    get routes(): {
+        [key: string]: any;
+        path: string;
+    }[];
+    static styles: import("lit").CSSResult;
+    render(): TemplateResult;
+    useRouter(): {
+        path: string;
+        params: Record<string, string>;
+    };
+    connectedCallback(): void;
+    render_united(): TemplateResult;
+    render_slotted(): TemplateResult;
+    render_field(): TemplateResult;
+    fieldComponent(usedRouteTemplate: string): null | TemplateResult;
+    slottedCompoent(usedRouteTemplate: string, ObjectArrayIncludePath: Array<{
+        path: string;
+        slotElement?: string;
+        [key: string]: any;
+    }>): null | TemplateResult;
+    static sortRoutesPaths(ObjectArrayIncludePath: Array<{
+        path: string;
+        [key: string]: any;
+    }>): Array<{
+        path: string;
+    }>;
+    static useWhichRoute(ObjectArrayIncludePath: Array<{
+        path: string;
+        [key: string]: any;
+    }>, path: string, baseURL?: string): string;
+    static parseRouterParams(routeTemplate: string, originpath: string): Record<string, string>;
+    static updateAll(): void;
+}
+export default RouteView;
+declare global {
+    interface HTMLElementTagNameMap {
+        "route-view": RouteView;
+    }
+}
 //# sourceMappingURL=route-view.d.ts.map

package/view/route-view.js

@@ -1,261 +1,261 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var RouteView_1;
-import { conf, css, define, html, LitElement, property } from "../deps.js";
-import { unsafeHTML } from "lit/directives/unsafe-html.js";
-let RouteView = RouteView_1 = class RouteView extends LitElement {
-    constructor() {
-        super(...arguments);
-        this._routes = [];
-        this.params = {};
-        this.static = false;
-        this.type = "united";
-        this.baseURL = "";
-        this.path = "";
-        this.override = false;
-        this.compoent = null;
-    }
-    set routes(v) {
-        if (Object.prototype.toString.call(v) !== "[object Array]") {
-            this._routes = [];
-            return;
-        }
-        if (this.static) {
-            this._routes = v;
-        }
-        else {
-            this._routes = RouteView_1.sortRoutesPaths(v);
-        }
-        this.requestUpdate();
-    }
-    get routes() {
-        return this._routes;
-    }
-    render() {
-        var _a, _b, _c;
-        if (this.type === "field") {
-            return (_a = this.render_field()) !== null && _a !== void 0 ? _a : html `<slot></slot>`;
-        }
-        if (this.type === "slotted" || this.type === "child") {
-            return (_b = this.render_slotted()) !== null && _b !== void 0 ? _b : html `<slot></slot>`;
-        }
-        return (_c = this.render_united()) !== null && _c !== void 0 ? _c : html `<slot></slot>`;
-    }
-    useRouter() {
-        return {
-            path: this.path,
-            params: this.params,
-        };
-    }
-    connectedCallback() {
-        super.connectedCallback();
-        this.path = window.location.pathname;
-        window.addEventListener("popstate", (e) => {
-            this.path = window.location.pathname;
-        });
-        if (!this.override)
-            return;
-        const pushHistory = history.pushState;
-        history.pushState = function () {
-            pushHistory.apply(this, arguments);
-            this.path = window.location.pathname;
-        };
-        const replaceHistory = history.replaceState;
-        history.replaceState = function () {
-            replaceHistory.apply(this, arguments);
-            this.path = window.location.pathname;
-        };
-    }
-    render_united() {
-        const slottedCompoent = this.render_slotted();
-        if (slottedCompoent)
-            return slottedCompoent;
-        const Compoent = this.render_field();
-        return Compoent;
-    }
-    render_slotted() {
-        const childNodes = this.querySelectorAll(":scope > *[slot]");
-        const slots = Array.from(childNodes).map((node) => {
-            const slotname = node.getAttribute("slot");
-            return {
-                path: this.baseURL + slotname,
-                slotname,
-            };
-        });
-        let slotsSort;
-        if (this.static) {
-            slotsSort = slots;
-        }
-        else {
-            slotsSort = RouteView_1.sortRoutesPaths(slots);
-        }
-        const usedRouteTemplate = RouteView_1.useWhichRoute(slotsSort, this.path);
-        const Compoent = this.slottedCompoent(usedRouteTemplate, slotsSort);
-        return Compoent;
-    }
-    render_field() {
-        const usedRouteTemplate = RouteView_1.useWhichRoute(this.routes, this.path);
-        const RouterParmasObject = RouteView_1.parseRouterParams(usedRouteTemplate, this.path);
-        this.params = RouterParmasObject;
-        const Compoent = this.fieldComponent(usedRouteTemplate);
-        return Compoent;
-    }
-    fieldComponent(usedRouteTemplate) {
-        if (!usedRouteTemplate)
-            return;
-        const route = this.routes.find((r) => r.path === usedRouteTemplate);
-        if (!route)
-            return null;
-        return route.component || (route.html ? unsafeHTML(route.html) : null);
-    }
-    slottedCompoent(usedRouteTemplate, ObjectArrayIncludePath) {
-        if (!usedRouteTemplate)
-            return;
-        const slotElement = ObjectArrayIncludePath.find((s) => s.path === usedRouteTemplate);
-        if (!slotElement)
-            return null;
-        const RouterParmasObject = RouteView_1.parseRouterParams(usedRouteTemplate, this.path);
-        this.params = RouterParmasObject;
-        return html `<slot name="${slotElement.slotname}"></slot>`;
-    }
-    static sortRoutesPaths(ObjectArrayIncludePath) {
-        const all = ObjectArrayIncludePath.map((route) => {
-            const path = route.path;
-            const pathArray = path.split("/");
-            const Single_dynamicRouteCount = pathArray.filter((p) => p.startsWith(":")).length;
-            return {
-                ...route,
-                path,
-                Single_dynamicRouteCount,
-            };
-        });
-        const allSort = all.sort((a, b) => a.Single_dynamicRouteCount - b.Single_dynamicRouteCount);
-        const multi = allSort.filter((route) => {
-            const path = route.path;
-            const pathArray = path.split("/");
-            const double_dynamicRouteCount = pathArray.filter((p) => p.startsWith("...") || p.startsWith("*")).length;
-            return double_dynamicRouteCount > 0;
-        });
-        multi.sort((a, b) => {
-            const aIndex = a.path.split("/").findIndex((template) => template.startsWith("...") || template.startsWith("*"));
-            const bIndex = b.path.split("/").findIndex((template) => template.startsWith("...") || template.startsWith("*"));
-            return aIndex !== -1 && bIndex !== -1 ? bIndex - aIndex : 0;
-        });
-        const sigle = allSort.filter((route) => {
-            const path = route.path;
-            const pathArray = path.split("/");
-            const double_dynamicRouteCount = pathArray.filter((p) => p.startsWith("...") || p.startsWith("*")).length;
-            return double_dynamicRouteCount === 0;
-        });
-        return [...sigle, ...multi];
-    }
-    static useWhichRoute(ObjectArrayIncludePath, path, baseURL = "") {
-        const originpath = baseURL + path;
-        const originsplits = originpath.split("/").slice(1);
-        const routes = ObjectArrayIncludePath;
-        const pathTemplateArray = routes.map((r) => r.path);
-        for (const pathTemplate of pathTemplateArray) {
-            const pathsplits = pathTemplate.split("/").slice(1);
-            const ifmatched = pathsplits.every((pathsplit, index) => {
-                const originsplit = originsplits[index];
-                if (pathsplit.startsWith(":")) {
-                    return originsplits.length <= pathsplits.length;
-                }
-                else if (pathsplit.startsWith("...")) {
-                    return originsplits.length >= pathsplits.length;
-                }
-                else {
-                    return originsplits.length === pathsplits.length && originsplit === pathsplit;
-                }
-            });
-            if (ifmatched) {
-                return pathTemplate;
-            }
-        }
-        return null;
-        /*
-        const originpath: string = baseURL + path;
-        const routes = ObjectArrayIncludePath as Array<{ path?: string; }>;
-        const pathTemplateArray = routes.map((r) => r.path) as Array<string>;
-        for (const pathTemplate of pathTemplateArray) {
-          const pathsplits = pathTemplate.split("/").slice(1);
-          const reg = new RegExp(pathsplits.map((s: string) => {
-            if (s.startsWith(":")) {
-              return "^\/[^\/]+$";
-            } else if (s.startsWith("...") || s.startsWith("*")) {
-              return ".*";
-            } else {
-              return s;
-            }
-          }).join("/") + "$");
-          if (reg.test(originpath)) {
-            return pathTemplate;
-          }
-        }
-        return null;
-        */
-    }
-    static parseRouterParams(routeTemplate, originpath) {
-        if (!routeTemplate || !originpath)
-            return;
-        const params = {};
-        const originpathArray = originpath.split("/").splice(1);
-        const routeTemplateSplit = routeTemplate.split("/").splice(1);
-        for (const [index, path] of routeTemplateSplit.entries()) {
-            if (path.startsWith(":")) {
-                params[path.slice(1)] = originpathArray[index];
-            }
-            else if (path.startsWith("*")) {
-                params[path.slice(1)] = originpathArray.slice(index).join("/");
-            }
-            else if (path.startsWith("...")) {
-                params[path.slice(3)] = originpathArray.slice(index).join("/");
-            }
-            else {
-                if (path !== originpathArray[index]) {
-                    return;
-                }
-            }
-        }
-        return params;
-    }
-    static updateAll() {
-        const routeViewTagName = conf.namemap.get("route-view");
-        const routeViewArray = document.querySelectorAll(`${routeViewTagName}:not([override])`);
-        for (let index = 0, ArrayItem; (ArrayItem = routeViewArray[index]); index++) {
-            ArrayItem.path = window.location.pathname;
-        }
-    }
-};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var RouteView_1;
+import { conf, css, define, html, LitElement, property } from "../deps.js";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+let RouteView = RouteView_1 = class RouteView extends LitElement {
+    constructor() {
+        super(...arguments);
+        this._routes = [];
+        this.params = {};
+        this.static = false;
+        this.type = "united";
+        this.baseURL = "";
+        this.path = "";
+        this.override = false;
+        this.compoent = null;
+    }
+    set routes(v) {
+        if (Object.prototype.toString.call(v) !== "[object Array]") {
+            this._routes = [];
+            return;
+        }
+        if (this.static) {
+            this._routes = v;
+        }
+        else {
+            this._routes = RouteView_1.sortRoutesPaths(v);
+        }
+        this.requestUpdate();
+    }
+    get routes() {
+        return this._routes;
+    }
+    render() {
+        var _a, _b, _c;
+        if (this.type === "field") {
+            return (_a = this.render_field()) !== null && _a !== void 0 ? _a : html `<slot></slot>`;
+        }
+        if (this.type === "slotted" || this.type === "child") {
+            return (_b = this.render_slotted()) !== null && _b !== void 0 ? _b : html `<slot></slot>`;
+        }
+        return (_c = this.render_united()) !== null && _c !== void 0 ? _c : html `<slot></slot>`;
+    }
+    useRouter() {
+        return {
+            path: this.path,
+            params: this.params,
+        };
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.path = window.location.pathname;
+        window.addEventListener("popstate", (e) => {
+            this.path = window.location.pathname;
+        });
+        if (!this.override)
+            return;
+        const pushHistory = history.pushState;
+        history.pushState = function () {
+            pushHistory.apply(this, arguments);
+            this.path = window.location.pathname;
+        };
+        const replaceHistory = history.replaceState;
+        history.replaceState = function () {
+            replaceHistory.apply(this, arguments);
+            this.path = window.location.pathname;
+        };
+    }
+    render_united() {
+        const slottedCompoent = this.render_slotted();
+        if (slottedCompoent)
+            return slottedCompoent;
+        const Compoent = this.render_field();
+        return Compoent;
+    }
+    render_slotted() {
+        const childNodes = this.querySelectorAll(":scope > *[slot]");
+        const slots = Array.from(childNodes).map((node) => {
+            const slotname = node.getAttribute("slot");
+            return {
+                path: this.baseURL + slotname,
+                slotname,
+            };
+        });
+        let slotsSort;
+        if (this.static) {
+            slotsSort = slots;
+        }
+        else {
+            slotsSort = RouteView_1.sortRoutesPaths(slots);
+        }
+        const usedRouteTemplate = RouteView_1.useWhichRoute(slotsSort, this.path);
+        const Compoent = this.slottedCompoent(usedRouteTemplate, slotsSort);
+        return Compoent;
+    }
+    render_field() {
+        const usedRouteTemplate = RouteView_1.useWhichRoute(this.routes, this.path);
+        const RouterParmasObject = RouteView_1.parseRouterParams(usedRouteTemplate, this.path);
+        this.params = RouterParmasObject;
+        const Compoent = this.fieldComponent(usedRouteTemplate);
+        return Compoent;
+    }
+    fieldComponent(usedRouteTemplate) {
+        if (!usedRouteTemplate)
+            return;
+        const route = this.routes.find((r) => r.path === usedRouteTemplate);
+        if (!route)
+            return null;
+        return route.component || (route.html ? unsafeHTML(route.html) : null);
+    }
+    slottedCompoent(usedRouteTemplate, ObjectArrayIncludePath) {
+        if (!usedRouteTemplate)
+            return;
+        const slotElement = ObjectArrayIncludePath.find((s) => s.path === usedRouteTemplate);
+        if (!slotElement)
+            return null;
+        const RouterParmasObject = RouteView_1.parseRouterParams(usedRouteTemplate, this.path);
+        this.params = RouterParmasObject;
+        return html `<slot name="${slotElement.slotname}"></slot>`;
+    }
+    static sortRoutesPaths(ObjectArrayIncludePath) {
+        const all = ObjectArrayIncludePath.map((route) => {
+            const path = route.path;
+            const pathArray = path.split("/");
+            const Single_dynamicRouteCount = pathArray.filter((p) => p.startsWith(":")).length;
+            return {
+                ...route,
+                path,
+                Single_dynamicRouteCount,
+            };
+        });
+        const allSort = all.sort((a, b) => a.Single_dynamicRouteCount - b.Single_dynamicRouteCount);
+        const multi = allSort.filter((route) => {
+            const path = route.path;
+            const pathArray = path.split("/");
+            const double_dynamicRouteCount = pathArray.filter((p) => p.startsWith("...") || p.startsWith("*")).length;
+            return double_dynamicRouteCount > 0;
+        });
+        multi.sort((a, b) => {
+            const aIndex = a.path.split("/").findIndex((template) => template.startsWith("...") || template.startsWith("*"));
+            const bIndex = b.path.split("/").findIndex((template) => template.startsWith("...") || template.startsWith("*"));
+            return aIndex !== -1 && bIndex !== -1 ? bIndex - aIndex : 0;
+        });
+        const sigle = allSort.filter((route) => {
+            const path = route.path;
+            const pathArray = path.split("/");
+            const double_dynamicRouteCount = pathArray.filter((p) => p.startsWith("...") || p.startsWith("*")).length;
+            return double_dynamicRouteCount === 0;
+        });
+        return [...sigle, ...multi];
+    }
+    static useWhichRoute(ObjectArrayIncludePath, path, baseURL = "") {
+        const originpath = baseURL + path;
+        const originsplits = originpath.split("/").slice(1);
+        const routes = ObjectArrayIncludePath;
+        const pathTemplateArray = routes.map((r) => r.path);
+        for (const pathTemplate of pathTemplateArray) {
+            const pathsplits = pathTemplate.split("/").slice(1);
+            const ifmatched = pathsplits.every((pathsplit, index) => {
+                const originsplit = originsplits[index];
+                if (pathsplit.startsWith(":")) {
+                    return originsplits.length <= pathsplits.length;
+                }
+                else if (pathsplit.startsWith("...")) {
+                    return originsplits.length >= pathsplits.length;
+                }
+                else {
+                    return originsplits.length === pathsplits.length && originsplit === pathsplit;
+                }
+            });
+            if (ifmatched) {
+                return pathTemplate;
+            }
+        }
+        return null;
+        /*
+        const originpath: string = baseURL + path;
+        const routes = ObjectArrayIncludePath as Array<{ path?: string; }>;
+        const pathTemplateArray = routes.map((r) => r.path) as Array<string>;
+        for (const pathTemplate of pathTemplateArray) {
+          const pathsplits = pathTemplate.split("/").slice(1);
+          const reg = new RegExp(pathsplits.map((s: string) => {
+            if (s.startsWith(":")) {
+              return "^\/[^\/]+$";
+            } else if (s.startsWith("...") || s.startsWith("*")) {
+              return ".*";
+            } else {
+              return s;
+            }
+          }).join("/") + "$");
+          if (reg.test(originpath)) {
+            return pathTemplate;
+          }
+        }
+        return null;
+        */
+    }
+    static parseRouterParams(routeTemplate, originpath) {
+        if (!routeTemplate || !originpath)
+            return;
+        const params = {};
+        const originpathArray = originpath.split("/").splice(1);
+        const routeTemplateSplit = routeTemplate.split("/").splice(1);
+        for (const [index, path] of routeTemplateSplit.entries()) {
+            if (path.startsWith(":")) {
+                params[path.slice(1)] = originpathArray[index];
+            }
+            else if (path.startsWith("*")) {
+                params[path.slice(1)] = originpathArray.slice(index).join("/");
+            }
+            else if (path.startsWith("...")) {
+                params[path.slice(3)] = originpathArray.slice(index).join("/");
+            }
+            else {
+                if (path !== originpathArray[index]) {
+                    return;
+                }
+            }
+        }
+        return params;
+    }
+    static updateAll() {
+        const routeViewTagName = conf.namemap.get("route-view");
+        const routeViewArray = document.querySelectorAll(`${routeViewTagName}:not([override])`);
+        for (let index = 0, ArrayItem; (ArrayItem = routeViewArray[index]); index++) {
+            ArrayItem.path = window.location.pathname;
+        }
+    }
+};
 RouteView.styles = css `
     :host {
       display: contents;
     }
-  `;
-__decorate([
-    property({ type: Boolean })
-], RouteView.prototype, "static", void 0);
-__decorate([
-    property()
-], RouteView.prototype, "type", void 0);
-__decorate([
-    property()
-], RouteView.prototype, "baseURL", void 0);
-__decorate([
-    property()
-], RouteView.prototype, "path", void 0);
-__decorate([
-    property({ type: Boolean })
-], RouteView.prototype, "override", void 0);
-__decorate([
-    property({ type: Object })
-], RouteView.prototype, "compoent", void 0);
-RouteView = RouteView_1 = __decorate([
-    define("route-view")
-], RouteView);
-export { RouteView };
-export default RouteView;
+  `;
+__decorate([
+    property({ type: Boolean })
+], RouteView.prototype, "static", void 0);
+__decorate([
+    property()
+], RouteView.prototype, "type", void 0);
+__decorate([
+    property()
+], RouteView.prototype, "baseURL", void 0);
+__decorate([
+    property()
+], RouteView.prototype, "path", void 0);
+__decorate([
+    property({ type: Boolean })
+], RouteView.prototype, "override", void 0);
+__decorate([
+    property({ type: Object })
+], RouteView.prototype, "compoent", void 0);
+RouteView = RouteView_1 = __decorate([
+    define("route-view")
+], RouteView);
+export { RouteView };
+export default RouteView;

package/view/scroll-x.d.ts

@@ -1,15 +1,15 @@
-import STD from "./std.js";
-export declare class ScrollX extends STD {
-    static styles: import("lit").CSSResult;
-    get _section(): HTMLElement;
-    render(): import("lit-html").TemplateResult<1>;
-    firstUpdated(): void;
-    resize(): void;
-}
-export default ScrollX;
-declare global {
-    interface HTMLElementTagNameMap {
-        "scroll-x": ScrollX;
-    }
-}
+import STD from "./std.js";
+export declare class ScrollX extends STD {
+    static styles: import("lit").CSSResult;
+    get _section(): HTMLElement;
+    render(): import("lit-html").TemplateResult<1>;
+    firstUpdated(): void;
+    resize(): void;
+}
+export default ScrollX;
+declare global {
+    interface HTMLElementTagNameMap {
+        "scroll-x": ScrollX;
+    }
+}
 //# sourceMappingURL=scroll-x.d.ts.map