@rxdi/lit-html 0.7.118

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+    "singleQuote": true,
+    "printWidth": 80
+}

package/README.md

@@ -0,0 +1,49 @@
+# lit-html hard fork prepared for bundlers with removed `.js` files from extensions
+
+#### Install
+```bash
+npm i @rxdi/lit-html
+```
+
+Example component
+```typescript
+import { LitElement, Component, html, css } from '@rxdi/lit-html';
+
+/**
+ * @customElement rx-description
+ */
+@Component({
+  selector: 'rx-description',
+  style: css`
+    .description {
+      color: #222;
+      font-size: 14px;
+      font-weight: normal;
+      text-transform: uppercase;
+    }
+
+    .text {
+      color: #666;
+      font-size: 15px;
+      font-weight: normal;
+      line-height: 1.5;
+    }
+
+    .border {
+      border-top: 1px solid #e5e5e5;
+      margin-top: 20px;
+      padding-top: 20px;
+    }
+  `,
+  template(this: DescriptionListComponent) {
+    return html`
+      <div class="container" part="container">
+        <slot name="description" class="description" part="description"></slot>
+        <slot name="text" class="text" part="text"></slot>
+        <div class="border" part="border"></div>
+      </div>
+    `;
+  }
+})
+export class DescriptionListComponent extends LitElement {}
+```

package/dist/async.d.ts

@@ -0,0 +1,24 @@
+import { noChange } from 'lit';
+import { AsyncDirective } from 'lit/async-directive';
+interface Unsubscribable {
+    unsubscribe(): void;
+}
+interface Subscribable<T> {
+    /** @deprecated Use an observer instead of a complete callback */
+    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable;
+    /** @deprecated Use an observer instead of an error callback */
+    subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Unsubscribable;
+    /** @deprecated Use an observer instead of a complete callback */
+    subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Unsubscribable;
+    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Unsubscribable;
+}
+declare class ObserveDirective extends AsyncDirective {
+    observable: Subscribable<unknown> | undefined;
+    unsubscribe: Unsubscribable;
+    render(asyncResult: Subscribable<unknown>): "" | typeof noChange;
+    subscribe(observable: Subscribable<unknown>): void;
+    disconnected(): void;
+    reconnected(): void;
+}
+export declare const async: (asyncResult: Subscribable<unknown>) => import("lit-html/directive").DirectiveResult<typeof ObserveDirective>;
+export {};

package/dist/async.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.async = void 0;
+const lit_1 = require("lit");
+const directive_1 = require("lit/directive");
+const async_directive_1 = require("lit/async-directive");
+class ObserveDirective extends async_directive_1.AsyncDirective {
+    // When the observable changes, unsubscribe to the old one and
+    // subscribe to the new one
+    render(asyncResult) {
+        if ('then' in asyncResult) {
+            Promise.resolve(asyncResult).then((v) => this.setValue(v));
+            return '';
+        }
+        if (this.observable !== asyncResult) {
+            this.unsubscribe.unsubscribe();
+            this.observable = asyncResult;
+            if (this.isConnected) {
+                this.subscribe(asyncResult);
+            }
+        }
+        return lit_1.noChange;
+    }
+    // Subscribes to the observable, calling the directive's asynchronous
+    // setValue API each time the value changes
+    subscribe(observable) {
+        this.unsubscribe = observable.subscribe((v) => {
+            this.setValue(v);
+        });
+    }
+    // When the directive is disconnected from the DOM, unsubscribe to ensure
+    // the directive instance can be garbage collected
+    disconnected() {
+        this.unsubscribe.unsubscribe();
+    }
+    // If the subtree the directive is in was disconneted and subsequently
+    // re-connected, re-subscribe to make the directive operable again
+    reconnected() {
+        this.subscribe(this.observable);
+    }
+}
+exports.async = directive_1.directive(ObserveDirective);

package/dist/decorators/component.decorator.d.ts

@@ -0,0 +1,37 @@
+import { CSSResult } from 'lit';
+import { TemplateResult } from 'lit';
+import { RXDIElement } from './tokens';
+export interface CustomElementConfig<T> {
+    selector: string;
+    template?: (self: T) => TemplateResult;
+    style?: CSSResult;
+    styles?: CSSResult[];
+    useShadow?: boolean;
+    extends?: string;
+    container?: HTMLElement | DocumentFragment;
+    providers?: Function[];
+    unsubscribeOnDestroy?: boolean;
+    /**
+     * It will unsubscribe from previous observables subscriptions
+     * Defaults to 5000 ms
+     * */
+    garbageCollectTimeout?: number;
+    garbageCollectOnUpdate?: boolean;
+}
+export declare const Component: <T>(config: CustomElementConfig<T>) => <K extends new (...args: any[]) => {}>(Base: K) => {
+    new (...args: any[]): {
+        getTemplateResult(): any;
+        OnInit(): any;
+        disconnectedCallback(): void;
+        connectedCallback(): void;
+        render(): any;
+        update(): void;
+        firstUpdated(): void;
+    };
+    styles: CSSResult[];
+    subscriptions: Map<any, any>;
+    collectGarbage(): void;
+    mapToSubscriptions(): void;
+    is(): string;
+    setElement: (document: RXDIElement) => K;
+} & K;

package/dist/decorators/component.decorator.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
+const lit_1 = require("lit");
+const legacyCustomElement = (tagName, clazz, options) => {
+    window.customElements.define(tagName, clazz, options);
+    return clazz;
+};
+const standardCustomElement = (tagName, descriptor, options) => {
+    const { kind, elements } = descriptor;
+    return {
+        kind,
+        elements,
+        // This callback is called once the class is otherwise fully defined
+        finisher(clazz) {
+            window.customElements.define(tagName, clazz, options);
+        },
+    };
+};
+const customElement = (tag, config = {}) => (Base) => {
+    var _a;
+    if (!tag || (tag && tag.indexOf('-') <= 0)) {
+        throw new Error(`You need at least 1 dash in the custom element name! ${Base}`);
+    }
+    config.styles = config.styles || [];
+    if (!('unsubscribeOnDestroy' in config)) {
+        config.unsubscribeOnDestroy = true;
+    }
+    const OnInit = Base.prototype.OnInit || function () { };
+    const OnDestroy = Base.prototype.OnDestroy || function () { };
+    const OnUpdate = Base.prototype.OnUpdate || function () { };
+    const OnUpdateFirst = Base.prototype.OnUpdateFirst || function () { };
+    const connectedCallback = Base.prototype.connectedCallback || function () { };
+    const disconnectedCallback = Base.prototype.disconnectedCallback || function () { };
+    const update = Base.prototype.update || function () { };
+    const firstUpdated = Base.prototype.firstUpdated || function () { };
+    if (!config.template) {
+        config.template = Base.prototype.render;
+    }
+    if (config.style) {
+        config.styles.push(config.style);
+    }
+    const ModifiedClass = (_a = class NoName extends Base {
+            static collectGarbage() {
+                ModifiedClass.subscriptions.forEach((sub) => sub.unsubscribe());
+                ModifiedClass.subscriptions.clear();
+            }
+            static mapToSubscriptions() {
+                // Override subscribe method so we can set subscription to new Map() later when component is unmounted we can unsubscribe
+                Object.keys(this).forEach((observable) => {
+                    if (this[observable] &&
+                        typeof this[observable].lift === 'function' &&
+                        typeof this[observable].subscribe === 'function') {
+                        const original = this[observable].subscribe.bind(this[observable]);
+                        this[observable].subscribe = (cb, err) => {
+                            const subscribe = original(cb, err);
+                            ModifiedClass.subscriptions.set(subscribe, subscribe);
+                            return subscribe;
+                        };
+                    }
+                });
+            }
+            static is() {
+                return tag;
+            }
+            getTemplateResult() {
+                return this;
+            }
+            OnInit() {
+                if (config.container) {
+                    lit_1.render(config.template.call(this), config.container);
+                    if (config.style) {
+                        const style = document.createElement('style');
+                        style.type = 'text/css';
+                        if (style['styleSheet']) {
+                            // This is required for IE8 and below.
+                            style['styleSheet'].cssText = config.style.toString();
+                        }
+                        else {
+                            style.appendChild(document.createTextNode(config.style.toString()));
+                        }
+                        config.container.prepend(style);
+                    }
+                }
+                return OnInit.call(this);
+            }
+            disconnectedCallback() {
+                if (config.unsubscribeOnDestroy) {
+                    ModifiedClass.collectGarbage();
+                }
+                OnDestroy.call(this);
+                disconnectedCallback.call(this);
+            }
+            connectedCallback() {
+                if (config.unsubscribeOnDestroy) {
+                    ModifiedClass.mapToSubscriptions.call(this);
+                }
+                if (!config.template) {
+                    config.template = () => lit_1.html ``;
+                }
+                // Check if element is pure HTMLElement or LitElement
+                // if (!this['performUpdate']) {
+                //   config.template = config.template.bind(this);
+                //   const clone = document.importNode(
+                //     config.template(this as never),
+                //     true
+                //   );
+                //   if (config.style) {
+                //     const style = document.createElement('style');
+                //     style.type = 'text/css';
+                //     if (style['styleSheet']) {
+                //       // This is required for IE8 and below.
+                //       style['styleSheet'].cssText = config.style.toString();
+                //     } else {
+                //       style.appendChild(document.createTextNode(config.style.toString()));
+                //     }
+                //     clone.append(style);
+                //   }
+                //   if (config.useShadow) {
+                //     this['attachShadow']({ mode: 'open' }).append(clone);
+                //   } else {
+                //     this['appendChild'](clone);
+                //   }
+                // }
+                connectedCallback.call(this);
+                OnInit.call(this);
+            }
+            render() {
+                return config.template.call(this);
+            }
+            update() {
+                if (config.garbageCollectOnUpdate) {
+                    ModifiedClass.collectGarbage();
+                }
+                update.call(this);
+                OnUpdate.call(this);
+                if (config.unsubscribeOnDestroy) {
+                    ModifiedClass.mapToSubscriptions.call(this);
+                }
+            }
+            firstUpdated() {
+                firstUpdated.call(this);
+                OnUpdateFirst.call(this);
+                if (config.unsubscribeOnDestroy) {
+                    ModifiedClass.mapToSubscriptions.call(this);
+                }
+            }
+        },
+        _a.styles = config.styles,
+        _a.subscriptions = new Map(),
+        _a.setElement = (document) => {
+            config.container = document;
+            return Base;
+        },
+        _a);
+    if (typeof ModifiedClass === 'function') {
+        legacyCustomElement(tag, ModifiedClass, {
+            extends: config.extends,
+        });
+    }
+    else {
+        standardCustomElement(tag, ModifiedClass, { extends: config.extends });
+    }
+    return ModifiedClass;
+};
+exports.Component = (config) => customElement(config.selector, config);

package/dist/decorators/custom-element.d.ts

@@ -0,0 +1,8 @@
+interface CustomElementConfig {
+    selector: string;
+    template: string;
+    style?: string;
+    useShadow?: boolean;
+}
+export declare const CustomElement: (config: CustomElementConfig) => (cls: any) => void;
+export {};

package/dist/decorators/custom-element.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomElement = void 0;
+const validateSelector = (selector) => {
+    if (selector.indexOf('-') <= 0) {
+        throw new Error('You need at least 1 dash in the custom element name!');
+    }
+};
+exports.CustomElement = (config) => cls => {
+    validateSelector(config.selector);
+    if (!config.template) {
+        throw new Error('You need to pass a template for the element');
+    }
+    const template = document.createElement('template');
+    if (config.style) {
+        config.template = `<style>${config.style}</style> ${config.template}`;
+    }
+    template.innerHTML = config.template;
+    const connectedCallback = cls.prototype.connectedCallback || function () { };
+    cls.prototype.connectedCallback = function () {
+        // Check if element is pure HTMLElement or LitElement
+        if (!this.performUpdate) {
+            const clone = document.importNode(template.content, true);
+            if (config.useShadow) {
+                this.attachShadow({ mode: 'open' }).appendChild(clone);
+            }
+            else {
+                this.appendChild(clone);
+            }
+        }
+        connectedCallback.call(this);
+    };
+    window.customElements.define(config.selector, cls);
+};

package/dist/decorators/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './on-before';
+export * from './on-destroy';
+export * from './on-init';
+export * from './on-update';
+export * from './on-update-first';

package/dist/decorators/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./on-before"), exports);
+__exportStar(require("./on-destroy"), exports);
+__exportStar(require("./on-init"), exports);
+__exportStar(require("./on-update"), exports);
+__exportStar(require("./on-update-first"), exports);

package/dist/decorators/hooks/on-before.d.ts

@@ -0,0 +1,3 @@
+export interface OnBefore {
+    OnBefore(): void;
+}

package/dist/decorators/hooks/on-before.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/decorators/hooks/on-destroy.d.ts

@@ -0,0 +1,3 @@
+export interface OnDestroy {
+    OnDestroy(): void;
+}

package/dist/decorators/hooks/on-destroy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/decorators/hooks/on-init.d.ts

@@ -0,0 +1,3 @@
+export interface OnInit {
+    OnInit(): void;
+}

package/dist/decorators/hooks/on-init.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/decorators/hooks/on-update-first.d.ts

@@ -0,0 +1,3 @@
+export interface OnUpdateFirst {
+    OnUpdateFirst(): void;
+}

package/dist/decorators/hooks/on-update-first.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/decorators/hooks/on-update.d.ts

@@ -0,0 +1,3 @@
+export interface OnUpdate {
+    OnUpdate(): void;
+}

package/dist/decorators/hooks/on-update.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './component.decorator';
+export * from './hooks/index';
+export * from './tokens';

package/dist/decorators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./component.decorator"), exports);
+__exportStar(require("./hooks/index"), exports);
+__exportStar(require("./tokens"), exports);

package/dist/decorators/tokens.d.ts

@@ -0,0 +1,20 @@
+import { CSSResult, CSSResultArray, TemplateResult } from 'lit';
+export declare class Subscription {
+    static EMPTY: Subscription;
+    closed: boolean;
+    protected _parentOrParents: Subscription | Subscription[];
+    private _subscriptions;
+    constructor(unsubscribe?: () => void);
+    unsubscribe(): void;
+}
+export declare class RXDIElement extends HTMLElement {
+    static setElement?<T>(component: T, document: RXDIElement): T;
+    static is?(document: RXDIElement): RXDIElement;
+    static styles?: CSSResult | CSSResultArray;
+    static subscriptions?: Map<Subscription, Subscription>;
+    getTemplateResult?(): TemplateResult;
+    OnBefore?(): void;
+    OnInit?(): void;
+    OnUpdate?(): void;
+    OnUpdateFirst?(): void;
+}

package/dist/decorators/tokens.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RXDIElement = void 0;
+class RXDIElement extends HTMLElement {
+}
+exports.RXDIElement = RXDIElement;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from './decorators/index';
+export * from './async';
+export * from 'lit';
+export * from 'lit/decorators';
+export * from 'lit/directives/class-map';
+export * from 'lit/directives/async-append';
+export * from 'lit/directives/async-replace';
+export * from 'lit/directives/cache';
+export * from 'lit/directives/guard';
+export * from 'lit/directives/if-defined';
+export * from 'lit/directives/live';
+export * from 'lit/directives/ref';
+export * from 'lit/directives/repeat';
+export * from 'lit/directives/style-map';
+export * from 'lit/directives/template-content';
+export * from 'lit/directives/unsafe-html';
+export * from 'lit/directives/unsafe-svg';
+export * from 'lit/directives/until';

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorators/index"), exports);
+__exportStar(require("./async"), exports);
+__exportStar(require("lit"), exports);
+__exportStar(require("lit/decorators"), exports);
+__exportStar(require("lit/directives/class-map"), exports);
+__exportStar(require("lit/directives/async-append"), exports);
+__exportStar(require("lit/directives/async-replace"), exports);
+__exportStar(require("lit/directives/cache"), exports);
+__exportStar(require("lit/directives/guard"), exports);
+__exportStar(require("lit/directives/if-defined"), exports);
+__exportStar(require("lit/directives/live"), exports);
+__exportStar(require("lit/directives/ref"), exports);
+__exportStar(require("lit/directives/repeat"), exports);
+__exportStar(require("lit/directives/style-map"), exports);
+__exportStar(require("lit/directives/template-content"), exports);
+__exportStar(require("lit/directives/unsafe-html"), exports);
+__exportStar(require("lit/directives/unsafe-svg"), exports);
+__exportStar(require("lit/directives/until"), exports);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@rxdi/lit-html",
+  "version": "0.7.118",
+  "main": "./dist/index.js",
+  "author": "Kristiyan Tachev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rxdi/lit-html"
+  },
+  "scripts": {
+    "build": "tsc || true"
+  },
+  "dependencies": {
+    "lit": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^12.0.10",
+    "typescript": "^3.9.3"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "typings": "./dist/index.d.ts"
+}

package/types/env.d.ts

@@ -0,0 +1,28 @@
+interface ShadyCSS {
+  styleElement(host: Element, overrideProps?: {[key: string]: string}): void;
+  getComputedStyleValue(element: Element, property: string): string;
+  ScopingShim: {prepareAdoptedCssText(cssText: string[], name: string): void;};
+  nativeShadow: boolean;
+}
+
+interface ShadyDOM {
+  inUse: boolean;
+}
+
+interface Window {
+  ShadyCSS?: ShadyCSS;
+  ShadyDOM?: ShadyDOM;
+  ShadowRoot: typeof ShadowRoot;
+}
+
+// Augment existing types with styling API
+interface ShadowRoot {
+  adoptedStyleSheets: CSSStyleSheet[];
+}
+
+declare var ShadowRoot: {prototype: ShadowRoot; new (): ShadowRoot;}
+
+interface CSSStyleSheet {
+  replaceSync(cssText: string): void;
+  replace(cssText: string): Promise<unknown>;
+}