@pb33f/cowboy-components 0.0.1 → 0.0.3

package/dist/css/alerts.css.d.ts

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

package/dist/css/alerts.css.js

@@ -0,0 +1,89 @@
+import { css } from "lit";
+export default css `
+    
+    strong {
+        display: block;
+        margin-bottom: var(--global-space);
+    }
+    
+    sl-alert::part(base) {
+        font: var(--font-stack);
+        color: var(--font-color);
+        border: none;
+        border-radius: 0;
+        background-color: var(--error-color-verylowalpha);
+    }
+   
+    sl-alert.error::part(base) {
+        border: 1px dashed var(--error-color);
+        background-color: var(--terminal-background);
+    }
+    sl-alert.error::part(icon) {
+        color: var(--error-color);
+        font-size: 1.5rem;
+    }
+    sl-alert.error > strong {
+        color: var(--error-color);
+        font: 1.2rem var(--font-stack-bold);
+    }
+
+    sl-alert.warning::part(icon) {
+        color: var(--warn-300);
+        font-size: 1.5rem;
+    }
+    sl-alert.warning::part(base) {
+        border: 1px dashed var(--warn-200);
+        background-color: var(--terminal-background);
+    }
+ 
+    sl-alert.warning > strong {
+        color: var(--warn-200);
+        font: 1.2rem var(--font-stack-bold);
+    }
+    
+    sl-alert.info::part(base) {
+        border: 1px dashed var(--primary-color);
+        background-color: var(--terminal-background);
+    }
+    sl-alert.info::part(icon) {
+        color: var(--primary-color);
+        font-size: 1.5rem;
+    }
+    sl-alert.info > strong {
+        font: 1.2rem var(--font-stack-bold);
+        color: var(--primary-color);
+    }
+    
+    sl-alert.success::part(base) {
+        border: 1px dashed var(--terminal-text);
+        background-color: var(--terminal-background);
+    }
+    sl-alert.success::part(icon) {
+        color: var(--terminal-text);
+        font-size: 1.5rem;
+    }
+    sl-alert.success > strong {
+        font: 1.2rem var(--font-stack-bold);
+        color: var(--terminal-text);
+    }
+
+    sl-alert.context::part(base) {
+        border: 1px dashed var(--code-border);
+        background-color: var(--terminal-background);
+    }
+    sl-alert.context::part(icon) {
+        color: var(--font-color-sub1);
+        font-size: 1.5rem;
+    }
+    sl-alert.context > strong {
+        font: 1.2rem var(--font-stack-bold);
+        color: var(--font-color);
+    }
+    
+    sl-alert::part(message) {
+        font: var(--font-stack);
+        padding-top: var(--global-padding);
+        padding-bottom: var(--global-padding);
+    }
+    
+`;

package/dist/css/prism.css.d.ts

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

package/dist/css/prism.css.js

@@ -0,0 +1,114 @@
+import { css } from "lit";
+export default css `
+  
+  code,
+  pre {
+    color: var(--font-color);
+    background: none;
+    font-family: var(--font-stack), sans-serif;
+    font-size: 1em;
+    text-align: left;
+    white-space: pre;
+    word-spacing: normal;
+    word-break: normal;
+    word-wrap: normal;
+    line-height: 1.5;
+    tab-size: 4;
+    hyphens: none;
+  }
+
+  /* Code blocks */
+
+  pre[class*="language-"] {
+    padding: 1em;
+    margin: .5em 0;
+    overflow: auto;
+    border-radius: 0.3em;
+  }
+
+
+  /* Inline code */
+
+  :not(pre) > code[class*="language-"] {
+    padding: .1em;
+    border-radius: .3em;
+    white-space: normal;
+  }
+
+  .token.comment,
+  .token.prolog,
+  .token.doctype,
+  .token.cdata {
+    color: #7f7f7f;
+  }
+
+  .token.punctuation {
+    color: #7f7f7f;
+  }
+
+  .token.namespace {
+    opacity: .7;
+  }
+
+  .token.property,
+  .token.tag,
+  .token.constant,
+  .token.symbol,
+  .token.deleted {
+    color: var(--primary-color);
+  }
+
+  .token.boolean,
+  .token.number {
+    color: var(--primary-color);
+  }
+
+  .token.selector,
+  .token.attr-name,
+  .token.string,
+  .token.char,
+  .token.builtin,
+  .token.inserted {
+    color: var(--secondary-color);
+  }
+
+  .token.operator,
+  .token.entity,
+  .token.url,
+  .language-css .token.string,
+  .style .token.string,
+  .token.variable {
+    color: var(--tertiary-color);
+  }
+
+  .token.atrule,
+  .token.attr-value,
+  .token.function,
+  .token.class-name {
+    color: var(--terminal-text);
+  }
+
+  .token.keyword {
+    color: var(--primary-color);
+  }
+
+  .token.regex,
+  .token.important {
+    color: #fd971f;
+  }
+
+  .token.important,
+  .token.bold {
+    font-weight: bold;
+  }
+
+  .token.italic {
+    font-style: italic;
+  }
+
+  .token.entity {
+    cursor: help;
+  }
+
+ 
+`;

package/dist/css/shared.css.d.ts

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

package/dist/css/shared.css.js

@@ -0,0 +1,116 @@
+import { css } from "lit";
+export default css `
+
+    a, a:visited, a:active {
+        text-decoration: none;
+        color: var(--primary-color);
+        font-family: var(--font-stack-bold), monospace;
+        font-weight: normal
+    }
+
+    a:hover {
+        color: var(--primary-color);
+        text-decoration: underline;
+    }
+    
+    hr {
+        height: 1px;
+        border-bottom: none;
+        border-left: none;
+        border-right: none;
+        border-top: 1px dashed var(--secondary-color);
+        margin-bottom: 20px;
+        margin-top: 10px;
+    }
+
+    .empty-data {
+        text-align: center;
+        padding-top: 20px;
+        color: var(--font-color-sub2)
+    }
+
+    .empty-data .mute-icon {
+        font-size: 100px;
+        margin-bottom: 20px;
+        color: var(--font-color-sub2);
+    }
+
+    .empty-data .binary-icon {
+        font-size: 100px;
+        margin-bottom: 20px;
+        color: var(--secondary-color);
+    }
+
+    .empty-data .up-icon {
+        font-size: 100px;
+        margin-bottom: 20px;
+        color: var(--primary-color);
+    }
+
+    .empty-data .ok-icon {
+        font-size: 100px;
+        margin-bottom: 20px;
+        color: var(--primary-color);
+    }
+
+    .empty-data.ok {
+        color: var(--primary-color);
+    }
+
+    .empty-data.engage {
+        padding-top: 90px;
+        color: var(--primary-color);
+    }
+
+    .binary-data .binary-icon {
+        font-size: 100px;
+        margin-bottom: 20px;
+        color: var(--primary-color);
+    }
+    
+    strong {
+        font-weight: normal;
+        font-family: var(--font-stack-bold), monospace;
+    }
+
+    .spin {
+        display: inline-block;
+        position: relative;
+        width: 35px;
+        height: 25px;
+    }
+    
+    .spin:after {
+        content: " ";
+        display: block;
+        border-radius: 50%;
+        width: 0;
+        height: 0;
+        margin: 8px;
+        box-sizing: border-box;
+        border: 10px solid var(--primary-color);
+        border-color: var(--primary-color) transparent var(--primary-color) transparent;
+        animation: spinner 1.2s infinite;
+    }
+    .pb33f-loader {
+        display: inline-block;
+        position: relative;
+        width: 100%;
+        height: 60px;
+    }
+
+    @keyframes spinner {
+        0% {
+            transform: rotate(0);
+            animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+        }
+        50% {
+            transform: rotate(900deg);
+            animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+        }
+        100% {
+            transform: rotate(1800deg);
+        }
+    }
+    
+`;

package/dist/model/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const WiretapChannel = "wiretap-broadcast";
+export declare const SpecChannel = "specs";
+export declare const WiretapControlsChannel = "controls";
+export declare const WiretapReportChannel = "report";
+export declare const WiretapConfigurationChannel = "configuration";
+export declare const WiretapStaticChannel = "wiretap-static-change";
+export declare const WiretapHttpTransactionStore = "http-transaction-store";
+export declare const WiretapSelectedTransactionStore = "selected-transaction-store";
+export declare const WiretapSpecStore = "wiretap-spec-store";
+export declare const WiretapControlsStore = "wiretap-controls-store";
+export declare const WiretapFiltersStore = "wiretap-filters-store";
+export declare const WiretapLinkCacheStore = "http-link-cache-store";
+export declare const WiretapLinkCacheKey = "http-link-cache";
+export declare const WiretapFiltersKey = "wiretap-filters";
+export declare const WiretapControlsKey = "wiretap-controls";
+export declare const WiretapCurrentSpec = "current-spec";
+export declare const GetCurrentSpecCommand = "get-current-spec";
+export declare const ChangeDelayCommand = "change-delay-request";
+export declare const RequestReportCommand = "generate-report-request";
+export declare const WiretapLocalStorage = "wiretap-transactions";
+export declare const NoSpec = "no-spec";
+export declare const TopicPrefix = "/topic/";
+export declare const QueuePrefix = "/queue/";

package/dist/model/constants.js

@@ -0,0 +1,23 @@
+export const WiretapChannel = "wiretap-broadcast";
+export const SpecChannel = "specs";
+export const WiretapControlsChannel = "controls";
+export const WiretapReportChannel = "report";
+export const WiretapConfigurationChannel = "configuration";
+export const WiretapStaticChannel = "wiretap-static-change";
+export const WiretapHttpTransactionStore = "http-transaction-store";
+export const WiretapSelectedTransactionStore = "selected-transaction-store";
+export const WiretapSpecStore = "wiretap-spec-store";
+export const WiretapControlsStore = "wiretap-controls-store";
+export const WiretapFiltersStore = "wiretap-filters-store";
+export const WiretapLinkCacheStore = "http-link-cache-store";
+export const WiretapLinkCacheKey = "http-link-cache";
+export const WiretapFiltersKey = "wiretap-filters";
+export const WiretapControlsKey = "wiretap-controls";
+export const WiretapCurrentSpec = "current-spec";
+export const GetCurrentSpecCommand = "get-current-spec";
+export const ChangeDelayCommand = "change-delay-request";
+export const RequestReportCommand = "generate-report-request";
+export const WiretapLocalStorage = "wiretap-transactions";
+export const NoSpec = "no-spec";
+export const TopicPrefix = "/topic/";
+export const QueuePrefix = "/queue/";

package/dist/model/controls.d.ts

@@ -0,0 +1,30 @@
+import { HttpTransaction } from "./http_transaction";
+export declare class WiretapControls {
+    globalDelay: number;
+}
+export declare class WiretapFilters {
+    constructor();
+    filterMethod: Filter;
+    filterKeywords: Filter[];
+    filterChain: Filter[];
+}
+export declare function AreFiltersActive(filters: WiretapFilters): boolean;
+export interface Filter {
+    id?: string;
+    keyword: string;
+}
+export interface ControlsResponse {
+    config: WiretapConfig;
+}
+export interface ControlsResponse {
+    config: WiretapConfig;
+}
+export interface ReportResponse {
+    transactions: HttpTransaction[];
+}
+export interface WiretapConfig {
+    redirectHost: string;
+    port: string;
+    monitorPort: string;
+    globalAPIDelay: number;
+}

package/dist/model/controls.js

@@ -0,0 +1,25 @@
+import { RanchUtils } from "@pb33f/ranch";
+export class WiretapControls {
+    constructor() {
+        this.globalDelay = 0;
+    }
+}
+export class WiretapFilters {
+    constructor() {
+        this.filterMethod = {
+            id: RanchUtils.genShortId(5),
+            keyword: "",
+        };
+        this.filterKeywords = [];
+        this.filterChain = [];
+    }
+}
+export function AreFiltersActive(filters) {
+    if (filters.filterMethod.keyword.length > 0) {
+        return true;
+    }
+    if (filters.filterKeywords.length > 0) {
+        return true;
+    }
+    return filters.filterChain.length > 0;
+}

package/dist/model/errors.d.ts

@@ -0,0 +1,7 @@
+export interface PlatformError {
+    detail: string;
+    instance: string;
+    statusL: number;
+    title: string;
+    type: string;
+}

package/dist/model/errors.js

@@ -0,0 +1 @@
+export {};

package/dist/model/exchange_method.d.ts

@@ -0,0 +1 @@
+export declare function ExchangeMethod(method: string): string;

package/dist/model/exchange_method.js

@@ -0,0 +1,16 @@
+export function ExchangeMethod(method) {
+    switch (method.toLowerCase()) {
+        case 'get':
+            return 'success';
+        case 'post':
+            return 'primary';
+        case 'put':
+            return 'primary';
+        case 'delete':
+            return 'danger';
+        case 'patch':
+            return 'warning';
+        default:
+            return 'neutral';
+    }
+}

package/dist/model/extract_content_type.d.ts

@@ -0,0 +1,34 @@
+import { HttpRequest, HttpResponse } from "./http_transaction";
+export declare const ContentTypeJSON = "application/json";
+export declare const ContentTypeFormEncoded = "application/x-www-form-urlencoded";
+export declare const ContentTypeXML = "application/xml";
+export declare const ContentTypeMultipartForm = "multipart/form-data";
+export declare const ContentTypeOctetStream = "application/octet-stream";
+export declare const ContentTypeText = "text/plain";
+export declare const ContentTypeHtml = "text/html";
+export interface FormDataEntry {
+    type: 'file' | 'field';
+    name: string;
+    filename?: string;
+    headers?: Map<string, string[]>;
+    value?: string;
+}
+export interface FormPart {
+    type: 'file' | 'field';
+    name: string;
+    value?: string[];
+    headers?: Map<string, string[]>;
+    files?: FormPart[];
+}
+export declare function ExtractContentType(value: string): string;
+export declare function IsJsonContentType(value: string): boolean;
+export declare function IsFormEncoded(value: string): boolean;
+export declare function IsXmlContentType(value: string): boolean;
+export declare function IsOctectStreamContentType(value: string): boolean;
+export declare function IsTextContentType(value: string): boolean;
+export declare function IsHtmlContentType(value: string): boolean;
+export declare function ExtractContentTypeFromRequest(request: HttpRequest): string;
+export declare function ExtractFullContentTypeFromRequest(request: HttpRequest): string;
+export declare function ExtractBoundaryFromFormEncodedContentType(contentType: string): string;
+export declare function ExtractContentTypeFromResponse(response: HttpResponse): string;
+export declare function ExtractFullContentTypeFromResponse(response: HttpResponse): string;

package/dist/model/extract_content_type.js

@@ -0,0 +1,78 @@
+export const ContentTypeJSON = "application/json";
+export const ContentTypeFormEncoded = "application/x-www-form-urlencoded";
+export const ContentTypeXML = "application/xml";
+export const ContentTypeMultipartForm = "multipart/form-data";
+export const ContentTypeOctetStream = "application/octet-stream";
+export const ContentTypeText = "text/plain";
+export const ContentTypeHtml = "text/html";
+export function ExtractContentType(value) {
+    return value.split(";")[0];
+}
+export function IsJsonContentType(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeJSON;
+}
+export function IsFormEncoded(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeFormEncoded;
+}
+export function IsXmlContentType(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeXML;
+}
+export function IsOctectStreamContentType(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeOctetStream;
+}
+export function IsTextContentType(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeText;
+}
+export function IsHtmlContentType(value) {
+    const contentType = ExtractContentType(value);
+    return contentType === ContentTypeHtml;
+}
+export function ExtractContentTypeFromRequest(request) {
+    let contentType = request.headers["content-type"];
+    if (contentType) {
+        return contentType;
+    }
+    contentType = request.headers["Content-Type"];
+    if (contentType?.indexOf(";") > 0) {
+        contentType = contentType.split(";")[0];
+    }
+    return contentType;
+}
+export function ExtractFullContentTypeFromRequest(request) {
+    let contentType = request.headers["content-type"];
+    if (contentType) {
+        return contentType;
+    }
+    contentType = request.headers["Content-Type"];
+    return contentType;
+}
+export function ExtractBoundaryFromFormEncodedContentType(contentType) {
+    return contentType.split("boundary=")[1];
+}
+export function ExtractContentTypeFromResponse(response) {
+    let contentType = response.headers["content-type"];
+    if (contentType) {
+        return contentType;
+    }
+    contentType = response.headers["Content-Type"];
+    if (contentType && contentType.indexOf(";") > 0) {
+        contentType = contentType.split(";")[0];
+    }
+    return contentType;
+}
+export function ExtractFullContentTypeFromResponse(response) {
+    let contentType = response.headers["content-type"];
+    if (contentType) {
+        return contentType;
+    }
+    contentType = response.headers["Content-Type"];
+    if (contentType && contentType.indexOf(";") > 0) {
+        contentType = contentType.split(";")[0];
+    }
+    return contentType;
+}

package/dist/model/extract_query.d.ts

@@ -0,0 +1 @@
+export declare function ExtractQueryString(queryString: string | undefined): Map<string, string>;

package/dist/model/extract_query.js

@@ -0,0 +1,11 @@
+export function ExtractQueryString(queryString) {
+    const query = new Map();
+    if (queryString) {
+        const queryItems = queryString.split("&");
+        for (const item of queryItems) {
+            const keyValuePair = item.split("=");
+            query.set(decodeURI(keyValuePair[0]), decodeURI(keyValuePair[1]));
+        }
+    }
+    return query;
+}

package/dist/model/http_transaction.d.ts

@@ -0,0 +1,78 @@
+import { Filter, WiretapFilters } from "./controls";
+export interface HttpCookie {
+    value?: string;
+    path?: string;
+    domain?: string;
+    expires?: string;
+    maxAge?: number;
+    secure?: boolean;
+    httpOnly?: boolean;
+}
+export interface SchemaValidationFailure {
+    reason?: string;
+    location?: string;
+    referenceSchema?: string;
+    referenceObject?: string;
+    line?: number;
+    column?: number;
+}
+export interface ValidationError {
+    message: string;
+    reason: string;
+    validationType: string;
+    validationSubType: string;
+    specLine: number;
+    specColumn: number;
+    howToFix: string;
+    validationErrors?: SchemaValidationFailure[];
+    context?: any;
+}
+export declare class HttpRequest {
+    url?: string;
+    method?: string;
+    path?: string;
+    host?: string;
+    query?: string;
+    headers?: any;
+    cookies?: any;
+    requestBody?: string;
+    timestamp?: number;
+    originalPath?: string;
+    droppedHeaders?: string[];
+    injectedHeaders?: any;
+    constructor();
+    extractHeaders(): Map<string, string>;
+    extractQuery(): Map<string, string>;
+    extractCookies(): Map<string, HttpCookie>;
+    checkContentType(contentType: string): boolean;
+}
+export declare class HttpResponse {
+    headers?: any;
+    cookies?: any;
+    statusCode?: number;
+    responseBody?: string;
+    timestamp?: number;
+    constructor();
+    extractHeaders(): Map<string, string>;
+    extractCookies(): Map<string, string>;
+}
+export declare class HttpTransactionBase {
+    id?: string;
+    timestamp?: number;
+}
+export interface HttpTransactionLink extends HttpTransactionBase {
+    queryString?: string;
+}
+export declare class HttpTransaction extends HttpTransactionBase {
+    delay?: number;
+    requestValidation?: ValidationError[];
+    httpResponse?: HttpResponse;
+    responseValidation?: ValidationError[];
+    containsChainLink?: boolean;
+    httpRequest?: HttpRequest;
+    constructor(timestamp?: number, delay?: number, httpRequest?: HttpRequest, httpResponse?: HttpResponse, id?: string, requestValidation?: ValidationError[], responseValidation?: ValidationError[], containsChainLink?: boolean);
+    matchesMethodFilter(filter: WiretapFilters): Filter | boolean;
+    matchesKeywordFilter(filter: WiretapFilters): Filter | boolean;
+    containsActiveLink(filter: WiretapFilters): Filter | boolean;
+}
+export declare function BuildLiveTransactionFromState(httpTransaction: HttpTransaction): HttpTransaction;