@pb33f/cowboy-components 0.0.14 → 0.1.1

package/dist/coffee-DgiPTF3g.js

@@ -0,0 +1,238 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.46.0(21007360cad28648bdf46282a2592cb47c3a7a6f)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var e = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    blockComment: ["###", "###"],
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+}, r = {
+  defaultToken: "",
+  ignoreCase: !0,
+  tokenPostfix: ".coffee",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+  keywords: [
+    "and",
+    "or",
+    "is",
+    "isnt",
+    "not",
+    "on",
+    "yes",
+    "@",
+    "no",
+    "off",
+    "true",
+    "false",
+    "null",
+    "this",
+    "new",
+    "delete",
+    "typeof",
+    "in",
+    "instanceof",
+    "return",
+    "throw",
+    "break",
+    "continue",
+    "debugger",
+    "if",
+    "else",
+    "switch",
+    "for",
+    "while",
+    "do",
+    "try",
+    "catch",
+    "finally",
+    "class",
+    "extends",
+    "super",
+    "undefined",
+    "then",
+    "unless",
+    "until",
+    "loop",
+    "of",
+    "by",
+    "when"
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
+  escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // identifiers and keywords
+      [/\@[a-zA-Z_]\w*/, "variable.predefined"],
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            this: "variable.predefined",
+            "@keywords": { token: "keyword.$0" },
+            "@default": ""
+          }
+        }
+      ],
+      // whitespace
+      [/[ \t\r\n]+/, ""],
+      // Comments
+      [/###/, "comment", "@comment"],
+      [/#.*$/, "comment"],
+      // regular expressions
+      ["///", { token: "regexp", next: "@hereregexp" }],
+      [/^(\s*)(@regEx)/, ["", "regexp"]],
+      [/(\()(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\=)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\[)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\!)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\&)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\|)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\?)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\{)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\;)(\s*)(@regEx)/, ["", "", "regexp"]],
+      // delimiters
+      [
+        /}/,
+        {
+          cases: {
+            "$S2==interpolatedstring": {
+              token: "string",
+              next: "@pop"
+            },
+            "@default": "@brackets"
+          }
+        }
+      ],
+      [/[{}()\[\]]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+      [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/0[0-7]+(?!\d)/, "number.octal"],
+      [/\d+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[,.]/, "delimiter"],
+      // strings:
+      [/"""/, "string", '@herestring."""'],
+      [/'''/, "string", "@herestring.'''"],
+      [
+        /"/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: '@string."' }
+          }
+        }
+      ],
+      [
+        /'/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: "@string.'" }
+          }
+        }
+      ]
+    ],
+    string: [
+      [/[^"'\#\\]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/\./, "string.escape.invalid"],
+      [
+        /#{/,
+        {
+          cases: {
+            '$S2=="': {
+              token: "string",
+              next: "root.interpolatedstring"
+            },
+            "@default": "string"
+          }
+        }
+      ],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/#/, "string"]
+    ],
+    herestring: [
+      [
+        /("""|''')/,
+        {
+          cases: {
+            "$1==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/[^#\\'"]+/, "string"],
+      [/['"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+      [/#/, "string"]
+    ],
+    comment: [
+      [/[^#]+/, "comment"],
+      [/###/, "comment", "@pop"],
+      [/#/, "comment"]
+    ],
+    hereregexp: [
+      [/[^\\\/#]+/, "regexp"],
+      [/\\./, "regexp"],
+      [/#.*$/, "comment"],
+      ["///[igm]*", { token: "regexp", next: "@pop" }],
+      [/\//, "regexp"]
+    ]
+  }
+};
+export {
+  e as conf,
+  r as language
+};

package/dist/components/editor/editor.d.ts

@@ -0,0 +1,27 @@
+import { LitElement } from "lit";
+import * as monaco from "monaco-editor";
+export declare class SpecEditor extends LitElement {
+    private container;
+    editor?: monaco.editor.IStandaloneCodeEditor;
+    model?: monaco.editor.ITextModel;
+    readOnly?: boolean;
+    theme?: string;
+    language?: string;
+    code?: string;
+    static styles: import("lit").CSSResult;
+    private firstboot;
+    render(): import("lit-html").TemplateResult<1>;
+    private getFile;
+    private getCode;
+    private getTheme;
+    private isDark;
+    setValue(value: string, firstboot?: boolean): void;
+    getValue(): string;
+    setMarkers(markers: monaco.editor.IMarkerData[]): void;
+    firstUpdated(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "pb33f-editor": SpecEditor;
+    }
+}

package/dist/components/editor/editor.js

@@ -0,0 +1,192 @@
+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;
+};
+import { css, html, LitElement } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { createRef, ref } from "lit/directives/ref.js";
+// -- Monaco Editor Imports --
+import * as monaco from "monaco-editor";
+// @ts-ignore
+import styles from "monaco-editor/min/vs/editor/editor.main.css?inline";
+// @ts-ignore
+import editorWorker from "monaco-editor/esm/vs/editor/editor.worker?worker";
+// @ts-ignore
+import htmlWorker from "monaco-editor/esm/vs/language/html/html.worker?worker";
+// @ts-ignore
+import cssWorker from "monaco-editor/esm/vs/language/css/css.worker?worker";
+// @ts-ignore
+import jsonWorker from "monaco-editor/esm/vs/language/json/json.worker?worker";
+import { EditorClicked, EditorUpdated } from "@/events/doctor";
+// @ts-ignore
+self.MonacoEnvironment = {
+    getWorker(_, label) {
+        if (label === "json") {
+            return new jsonWorker();
+        }
+        if (label === "html") {
+            return new htmlWorker();
+        }
+        if (label === "css" || label === "scss" || label === "less") {
+            return new cssWorker();
+        }
+        return new editorWorker();
+    },
+};
+let SpecEditor = class SpecEditor extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.container = createRef();
+    }
+    render() {
+        return html `
+            <style>
+                ${styles}
+            </style>
+            <main ${ref(this.container)}></main>
+        `;
+    }
+    getFile() {
+        if (this.children.length > 0)
+            return this.children[0];
+        return null;
+    }
+    getCode() {
+        if (this.code)
+            return this.code;
+        const file = this.getFile();
+        if (!file)
+            return;
+        return file.innerHTML.trim();
+    }
+    getTheme() {
+        if (this.theme)
+            return this.theme;
+        if (this.isDark())
+            return "vs-dark";
+        return "vs-light";
+    }
+    isDark() {
+        return (window.matchMedia &&
+            window.matchMedia("(prefers-color-scheme: dark)").matches);
+    }
+    setValue(value, firstboot = false) {
+        if (firstboot) {
+            this.firstboot = firstboot;
+        }
+        this.editor.setValue(value);
+    }
+    getValue() {
+        return this.editor.getValue();
+    }
+    setMarkers(markers) {
+        monaco.editor.removeAllMarkers("owner");
+        monaco.editor.setModelMarkers(this.model, "owner", markers);
+    }
+    firstUpdated() {
+        const options = {
+            base: 'vs-dark',
+            //renderSideBySide: false,
+            inherit: true,
+            rules: [
+                {
+                    "foreground": "E400FB",
+                    "token": "string"
+                },
+                {
+                    "foreground": "62C4FFFF",
+                    "token": "type"
+                },
+            ],
+            colors: {
+                'editor.fontFamily': 'arial',
+                'editor.foreground': '#ffffff',
+                'editor.background': '#0d1117',
+                'editorCursor.foreground': '#62C4FFFF',
+                'editor.lineHighlightBackground': '#E400FB30',
+                'editorLineNumber.foreground': '#6368747F',
+                'editorLineNumber.activeForeground': '#E400FB',
+                'editor.inactiveSelectionBackground': '#FF3C742D',
+                'diffEditor.removedTextBackground': '#FF3C741A',
+                'diffEditor.insertedTextBackground': '#62C4FF1A',
+            }
+        };
+        // @ts-ignore
+        monaco.editor.defineTheme("pb33f", options);
+        monaco.editor.setTheme('pb33f');
+        const uri = monaco.Uri.parse("inmemory://doc");
+        const value = this.getCode();
+        this.model = monaco.editor.createModel(value, "yaml", uri);
+        this.editor = monaco.editor.create(this.container.value, {
+            model: this.model,
+            language: 'yaml',
+            theme: 'pb33f',
+            readOnly: this.readOnly,
+            automaticLayout: true,
+            fontFamily: 'BerkeleyMono-Regular',
+            fontSize: 14,
+            minimap: {
+                enabled: false
+            },
+            hover: {
+                enabled: true
+            }
+        });
+        this.model.onDidChangeContent(() => {
+            if (!this.firstboot) {
+                this.dispatchEvent(new CustomEvent(EditorUpdated, {
+                    bubbles: true,
+                    composed: true,
+                    detail: {
+                        content: this.editor.getValue()
+                    }
+                }));
+            }
+            else {
+                this.firstboot = false;
+            }
+        });
+        this.editor.onMouseDown((e) => {
+            this.dispatchEvent(new CustomEvent(EditorClicked, {
+                bubbles: true,
+                composed: true,
+                detail: {
+                    line: e.target.position?.lineNumber,
+                    column: e.target.position?.column
+                }
+            }));
+            //this.editor?.getAction("editor.action.revealDefinition")!.run()
+        });
+        window
+            .matchMedia("(prefers-color-scheme: dark)")
+            .addEventListener("change", () => {
+            monaco.editor.setTheme(this.getTheme());
+        });
+    }
+};
+SpecEditor.styles = css `
+        main {
+            width: 100%;
+            height: 100%;
+            position: relative;
+            word-spacing: normal;
+        }
+    `;
+__decorate([
+    property({ type: Boolean, attribute: "readonly" })
+], SpecEditor.prototype, "readOnly", void 0);
+__decorate([
+    property()
+], SpecEditor.prototype, "theme", void 0);
+__decorate([
+    property()
+], SpecEditor.prototype, "language", void 0);
+__decorate([
+    property()
+], SpecEditor.prototype, "code", void 0);
+SpecEditor = __decorate([
+    customElement("pb33f-editor")
+], SpecEditor);
+export { SpecEditor };

package/dist/components/error-banner/error-banner.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/components/error-banner/error-banner.css.js

@@ -0,0 +1,23 @@
+import { css } from "lit";
+export default css `
+    .banner {
+        opacity: 0 ;
+        transition: all 0.5s;
+        height: 0;
+        position: absolute;
+        top: 0;
+        left: 0;
+        z-index: 1000;
+        width: 100%;
+        overflow: hidden;
+    }
+    
+    .visible {
+        height: 200px;
+        opacity: 1;
+        margin-bottom: 20px;
+        transition-timing-function: ease-out;
+    }
+    
+    
+`;

package/dist/components/error-banner/error-banner.d.ts

@@ -0,0 +1,9 @@
+import { LitElement } from "lit";
+export declare class ErrorBanner extends LitElement {
+    static styles: import("lit").CSSResult[];
+    errorMessage: string;
+    errorTitle: string;
+    visible: boolean;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/components/error-banner/error-banner.js

@@ -0,0 +1,40 @@
+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;
+};
+import { customElement, property } from "lit/decorators.js";
+import { html, LitElement } from "lit";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+import errorBannerCss from "./error-banner.css.js";
+let ErrorBanner = class ErrorBanner extends LitElement {
+    constructor() {
+        super();
+        this.errorTitle = "Error";
+        this.errorMessage = "An error occurred";
+        this.visible = false;
+    }
+    render() {
+        return html `
+            <div class="banner ${this.visible ? 'visible' : ''}">
+                <pb33f-attention-box type="error" headerText="${this.errorTitle}">
+                    ${unsafeHTML(this.errorMessage)}
+                </pb33f-attention-box>
+            </div>`;
+    }
+};
+ErrorBanner.styles = [errorBannerCss];
+__decorate([
+    property()
+], ErrorBanner.prototype, "errorMessage", void 0);
+__decorate([
+    property()
+], ErrorBanner.prototype, "errorTitle", void 0);
+__decorate([
+    property({ type: Boolean })
+], ErrorBanner.prototype, "visible", void 0);
+ErrorBanner = __decorate([
+    customElement("pb33f-error-banner")
+], ErrorBanner);
+export { ErrorBanner };

package/dist/components/mailing-list/mailing-list.js

@@ -8,7 +8,7 @@ import { customElement, property, query, state } from "lit/decorators.js";
 import { LitElement } from "lit";
 import { html } from "lit";
 import mailingListComponentsCss from "./mailing-list.css.js";
-import sharedCss from "../../css/shared.css.js";
+import sharedCss from "@/css/shared.css.js";
 let MailingList = class MailingList extends LitElement {
     constructor() {
         super();

package/dist/components/paginator/paginator-events.d.ts

@@ -0,0 +1,4 @@
+export declare const PaginatorFirstPage = "paginatorFirstPage";
+export declare const PaginatorLastPage = "paginatorLastPage";
+export declare const PaginatorNextPage = "paginatorNextPage";
+export declare const PaginatorPreviousPage = "paginator-previous-page";

package/dist/components/paginator/paginator-events.js

@@ -0,0 +1,4 @@
+export const PaginatorFirstPage = "paginatorFirstPage";
+export const PaginatorLastPage = "paginatorLastPage";
+export const PaginatorNextPage = "paginatorNextPage";
+export const PaginatorPreviousPage = "paginator-previous-page";

package/dist/components/paginator/paginator-navigator.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/components/paginator/paginator-navigator.css.js

@@ -0,0 +1,35 @@
+import { css } from "lit";
+export default css `
+    .paginator-navigation {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        background: var(--pagination-header);
+        border: 1px solid var(--secondary-color-lowalpha);
+
+    }
+    
+    .location {
+        color: var(--font-color-sub1);
+        font-size: 0.8rem;
+    }
+    
+    strong {
+        font-family: var(--font-stack-bold), monospace;
+        font-weight: normal;
+    }
+    
+    strong.current-page, strong.total {
+        color: var(--primary-color);
+    }
+
+    .result-range {
+        font-size: 0.8rem;
+        color: var(--font-color-sub1);
+    }
+    
+    .hide {
+        display: none;
+    }
+    
+`;

package/dist/components/paginator/paginator-navigator.d.ts

@@ -0,0 +1,27 @@
+import { LitElement } from "lit";
+import SlIconButton from "@shoelace-style/shoelace/cdn/components/icon-button/icon-button.component";
+import "@shoelace-style/shoelace/dist/components/format-number/format-number.js";
+export declare class PaginatorNavigation extends LitElement {
+    static styles: import("lit").CSSResult[];
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    homeButton: SlIconButton;
+    prevButton: SlIconButton;
+    nextButton: SlIconButton;
+    endButton: SlIconButton;
+    label: string;
+    hide: boolean;
+    constructor();
+    getRangeStart(): number;
+    getPagesRemaining(): number;
+    getRangeEnd(): number;
+    nextPage(): void;
+    previousPage(): void;
+    lastPage(): void;
+    firstPage(): void;
+    togglePrev(toggle: boolean): void;
+    toggleNext(toggle: boolean): void;
+    render(): import("lit-html").TemplateResult<1>;
+}