@rxdi/lit-html 0.7.157 → 0.7.159

package/dist/lit-html/directives/live.d.ts

@@ -1,42 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { AttributePart } from '../lit-html';
-import { Directive, DirectiveParameters, PartInfo } from '../directive';
-declare class LiveDirective extends Directive {
-    constructor(partInfo: PartInfo);
-    render(value: unknown): unknown;
-    update(part: AttributePart, [value]: DirectiveParameters<this>): unknown;
-}
-/**
- * Checks binding values against live DOM values, instead of previously bound
- * values, when determining whether to update the value.
- *
- * This is useful for cases where the DOM value may change from outside of
- * lit-html, such as with a binding to an `<input>` element's `value` property,
- * a content editable elements text, or to a custom element that changes it's
- * own properties or attributes.
- *
- * In these cases if the DOM value changes, but the value set through lit-html
- * bindings hasn't, lit-html won't know to update the DOM value and will leave
- * it alone. If this is not what you want--if you want to overwrite the DOM
- * value with the bound value no matter what--use the `live()` directive:
- *
- * ```js
- * html`<input .value=${live(x)}>`
- * ```
- *
- * `live()` performs a strict equality check agains the live DOM value, and if
- * the new value is equal to the live value, does nothing. This means that
- * `live()` should not be used when the binding will cause a type conversion. If
- * you use `live()` with an attribute binding, make sure that only strings are
- * passed in, or the binding will update every render.
- */
-export declare const live: (value: unknown) => import("../directive").DirectiveResult<typeof LiveDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { LiveDirective };

package/dist/lit-html/directives/live.js

@@ -1,79 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.live = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-const directive_helpers_1 = require("../directive-helpers");
-class LiveDirective extends directive_1.Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        if (!(partInfo.type === directive_1.PartType.PROPERTY ||
-            partInfo.type === directive_1.PartType.ATTRIBUTE ||
-            partInfo.type === directive_1.PartType.BOOLEAN_ATTRIBUTE)) {
-            throw new Error('The `live` directive is not allowed on child or event bindings');
-        }
-        if (!(0, directive_helpers_1.isSingleExpression)(partInfo)) {
-            throw new Error('`live` bindings can only contain a single expression');
-        }
-    }
-    render(value) {
-        return value;
-    }
-    update(part, [value]) {
-        if (value === lit_html_1.noChange || value === lit_html_1.nothing) {
-            return value;
-        }
-        const element = part.element;
-        const name = part.name;
-        if (part.type === directive_1.PartType.PROPERTY) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (value === element[name]) {
-                return lit_html_1.noChange;
-            }
-        }
-        else if (part.type === directive_1.PartType.BOOLEAN_ATTRIBUTE) {
-            if (!!value === element.hasAttribute(name)) {
-                return lit_html_1.noChange;
-            }
-        }
-        else if (part.type === directive_1.PartType.ATTRIBUTE) {
-            if (element.getAttribute(name) === String(value)) {
-                return lit_html_1.noChange;
-            }
-        }
-        // Resets the part's value, causing its dirty-check to fail so that it
-        // always sets the value.
-        (0, directive_helpers_1.setCommittedValue)(part);
-        return value;
-    }
-}
-/**
- * Checks binding values against live DOM values, instead of previously bound
- * values, when determining whether to update the value.
- *
- * This is useful for cases where the DOM value may change from outside of
- * lit-html, such as with a binding to an `<input>` element's `value` property,
- * a content editable elements text, or to a custom element that changes it's
- * own properties or attributes.
- *
- * In these cases if the DOM value changes, but the value set through lit-html
- * bindings hasn't, lit-html won't know to update the DOM value and will leave
- * it alone. If this is not what you want--if you want to overwrite the DOM
- * value with the bound value no matter what--use the `live()` directive:
- *
- * ```js
- * html`<input .value=${live(x)}>`
- * ```
- *
- * `live()` performs a strict equality check agains the live DOM value, and if
- * the new value is equal to the live value, does nothing. This means that
- * `live()` should not be used when the binding will cause a type conversion. If
- * you use `live()` with an attribute binding, make sure that only strings are
- * passed in, or the binding will update every render.
- */
-exports.live = (0, directive_1.directive)(LiveDirective);

package/dist/lit-html/directives/private-async-helpers.d.ts

@@ -1,57 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * Helper to iterate an AsyncIterable in its own closure.
- * @param iterable The iterable to iterate
- * @param callback The callback to call for each value. If the callback returns
- * `false`, the loop will be broken.
- */
-export declare const forAwaitOf: <T>(iterable: AsyncIterable<T>, callback: (value: T) => Promise<boolean>) => Promise<void>;
-/**
- * Holds a reference to an instance that can be disconnected and reconnected,
- * so that a closure over the ref (e.g. in a then function to a promise) does
- * not strongly hold a ref to the instance. Approximates a WeakRef but must
- * be manually connected & disconnected to the backing instance.
- */
-export declare class PseudoWeakRef<T> {
-    private _ref?;
-    constructor(ref: T);
-    /**
-     * Disassociates the ref with the backing instance.
-     */
-    disconnect(): void;
-    /**
-     * Reassociates the ref with the backing instance.
-     */
-    reconnect(ref: T): void;
-    /**
-     * Retrieves the backing instance (will be undefined when disconnected)
-     */
-    deref(): T;
-}
-/**
- * A helper to pause and resume waiting on a condition in an async function
- */
-export declare class Pauser {
-    private _promise?;
-    private _resolve?;
-    /**
-     * When paused, returns a promise to be awaited; when unpaused, returns
-     * undefined. Note that in the microtask between the pauser being resumed
-     * an an await of this promise resolving, the pauser could be paused again,
-     * hence callers should check the promise in a loop when awaiting.
-     * @returns A promise to be awaited when paused or undefined
-     */
-    get(): Promise<void>;
-    /**
-     * Creates a promise to be awaited
-     */
-    pause(): void;
-    /**
-     * Resolves the promise which may be awaited
-     */
-    resume(): void;
-}

package/dist/lit-html/directives/private-async-helpers.js

@@ -1,117 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pauser = exports.PseudoWeakRef = exports.forAwaitOf = void 0;
-// Note, this module is not included in package exports so that it's private to
-// our first-party directives. If it ends up being useful, we can open it up and
-// export it.
-/**
- * Helper to iterate an AsyncIterable in its own closure.
- * @param iterable The iterable to iterate
- * @param callback The callback to call for each value. If the callback returns
- * `false`, the loop will be broken.
- */
-const forAwaitOf = (iterable, callback) => { var iterable_1, iterable_1_1; return __awaiter(void 0, void 0, void 0, function* () {
-    var e_1, _a;
-    try {
-        for (iterable_1 = __asyncValues(iterable); iterable_1_1 = yield iterable_1.next(), !iterable_1_1.done;) {
-            const v = iterable_1_1.value;
-            if ((yield callback(v)) === false) {
-                return;
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) yield _a.call(iterable_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-}); };
-exports.forAwaitOf = forAwaitOf;
-/**
- * Holds a reference to an instance that can be disconnected and reconnected,
- * so that a closure over the ref (e.g. in a then function to a promise) does
- * not strongly hold a ref to the instance. Approximates a WeakRef but must
- * be manually connected & disconnected to the backing instance.
- */
-class PseudoWeakRef {
-    constructor(ref) {
-        this._ref = ref;
-    }
-    /**
-     * Disassociates the ref with the backing instance.
-     */
-    disconnect() {
-        this._ref = undefined;
-    }
-    /**
-     * Reassociates the ref with the backing instance.
-     */
-    reconnect(ref) {
-        this._ref = ref;
-    }
-    /**
-     * Retrieves the backing instance (will be undefined when disconnected)
-     */
-    deref() {
-        return this._ref;
-    }
-}
-exports.PseudoWeakRef = PseudoWeakRef;
-/**
- * A helper to pause and resume waiting on a condition in an async function
- */
-class Pauser {
-    constructor() {
-        this._promise = undefined;
-        this._resolve = undefined;
-    }
-    /**
-     * When paused, returns a promise to be awaited; when unpaused, returns
-     * undefined. Note that in the microtask between the pauser being resumed
-     * an an await of this promise resolving, the pauser could be paused again,
-     * hence callers should check the promise in a loop when awaiting.
-     * @returns A promise to be awaited when paused or undefined
-     */
-    get() {
-        return this._promise;
-    }
-    /**
-     * Creates a promise to be awaited
-     */
-    pause() {
-        var _a;
-        (_a = this._promise) !== null && _a !== void 0 ? _a : (this._promise = new Promise((resolve) => (this._resolve = resolve)));
-    }
-    /**
-     * Resolves the promise which may be awaited
-     */
-    resume() {
-        var _a;
-        (_a = this._resolve) === null || _a === void 0 ? void 0 : _a.call(this);
-        this._promise = this._resolve = undefined;
-    }
-}
-exports.Pauser = Pauser;

package/dist/lit-html/directives/ref.d.ts

@@ -1,65 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ElementPart } from '../lit-html';
-import { AsyncDirective } from '../async-directive';
-/**
- * Creates a new Ref object, which is container for a reference to an element.
- */
-export declare const createRef: <T = Element>() => Ref<T>;
-/**
- * An object that holds a ref value.
- */
-declare class Ref<T = Element> {
-    /**
-     * The current Element value of the ref, or else `undefined` if the ref is no
-     * longer rendered.
-     */
-    readonly value?: T;
-}
-export type { Ref };
-export declare type RefOrCallback = Ref | ((el: Element | undefined) => void);
-declare class RefDirective extends AsyncDirective {
-    private _element?;
-    private _ref?;
-    private _context;
-    render(_ref: RefOrCallback): symbol;
-    update(part: ElementPart, [ref]: Parameters<this['render']>): symbol;
-    private _updateRefValue;
-    private get _lastElementForRef();
-    disconnected(): void;
-    reconnected(): void;
-}
-/**
- * Sets the value of a Ref object or calls a ref callback with the element it's
- * bound to.
- *
- * A Ref object acts as a container for a reference to an element. A ref
- * callback is a function that takes an element as its only argument.
- *
- * The ref directive sets the value of the Ref object or calls the ref callback
- * during rendering, if the referenced element changed.
- *
- * Note: If a ref callback is rendered to a different element position or is
- * removed in a subsequent render, it will first be called with `undefined`,
- * followed by another call with the new element it was rendered to (if any).
- *
- * ```js
- * // Using Ref object
- * const inputRef = createRef();
- * render(html`<input ${ref(inputRef)}>`, container);
- * inputRef.value.focus();
- *
- * // Using callback
- * const callback = (inputElement) => inputElement.focus();
- * render(html`<input ${ref(callback)}>`, container);
- * ```
- */
-export declare const ref: (_ref: RefOrCallback) => import("../directive").DirectiveResult<typeof RefDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { RefDirective };

package/dist/lit-html/directives/ref.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ref = exports.createRef = void 0;
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-const lit_html_1 = require("../lit-html");
-const async_directive_1 = require("../async-directive");
-/**
- * Creates a new Ref object, which is container for a reference to an element.
- */
-const createRef = () => new Ref();
-exports.createRef = createRef;
-/**
- * An object that holds a ref value.
- */
-class Ref {
-}
-// When callbacks are used for refs, this map tracks the last value the callback
-// was called with, for ensuring a directive doesn't clear the ref if the ref
-// has already been rendered to a new spot
-const lastElementForCallback = new WeakMap();
-class RefDirective extends async_directive_1.AsyncDirective {
-    render(_ref) {
-        return lit_html_1.nothing;
-    }
-    update(part, [ref]) {
-        var _a;
-        const refChanged = ref !== this._ref;
-        if (refChanged && this._ref !== undefined) {
-            // The ref passed to the directive has changed;
-            // unset the previous ref's value
-            this._updateRefValue(undefined);
-        }
-        if (refChanged || this._lastElementForRef !== this._element) {
-            // We either got a new ref or this is the first render;
-            // store the ref/element & update the ref value
-            this._ref = ref;
-            this._context = (_a = part.options) === null || _a === void 0 ? void 0 : _a.host;
-            this._updateRefValue((this._element = part.element));
-        }
-        return lit_html_1.nothing;
-    }
-    _updateRefValue(element) {
-        if (typeof this._ref === 'function') {
-            // If the current ref was called with a previous value, call with
-            // `undefined`; We do this to ensure callbacks are called in a consistent
-            // way regardless of whether a ref might be moving up in the tree (in
-            // which case it would otherwise be called with the new value before the
-            // previous one unsets it) and down in the tree (where it would be unset
-            // before being set)
-            if (lastElementForCallback.get(this._ref) !== undefined) {
-                this._ref.call(this._context, undefined);
-            }
-            lastElementForCallback.set(this._ref, element);
-            // Call the ref with the new element value
-            if (element !== undefined) {
-                this._ref.call(this._context, element);
-            }
-        }
-        else {
-            this._ref.value = element;
-        }
-    }
-    get _lastElementForRef() {
-        var _a;
-        return typeof this._ref === 'function'
-            ? lastElementForCallback.get(this._ref)
-            : (_a = this._ref) === null || _a === void 0 ? void 0 : _a.value;
-    }
-    disconnected() {
-        // Only clear the box if our element is still the one in it (i.e. another
-        // directive instance hasn't rendered its element to it before us); that
-        // only happens in the event of the directive being cleared (not via manual
-        // disconnection)
-        if (this._lastElementForRef === this._element) {
-            this._updateRefValue(undefined);
-        }
-    }
-    reconnected() {
-        // If we were manually disconnected, we can safely put our element back in
-        // the box, since no rendering could have occurred to change its state
-        this._updateRefValue(this._element);
-    }
-}
-/**
- * Sets the value of a Ref object or calls a ref callback with the element it's
- * bound to.
- *
- * A Ref object acts as a container for a reference to an element. A ref
- * callback is a function that takes an element as its only argument.
- *
- * The ref directive sets the value of the Ref object or calls the ref callback
- * during rendering, if the referenced element changed.
- *
- * Note: If a ref callback is rendered to a different element position or is
- * removed in a subsequent render, it will first be called with `undefined`,
- * followed by another call with the new element it was rendered to (if any).
- *
- * ```js
- * // Using Ref object
- * const inputRef = createRef();
- * render(html`<input ${ref(inputRef)}>`, container);
- * inputRef.value.focus();
- *
- * // Using callback
- * const callback = (inputElement) => inputElement.focus();
- * render(html`<input ${ref(callback)}>`, container);
- * ```
- */
-exports.ref = (0, async_directive_1.directive)(RefDirective);

package/dist/lit-html/directives/repeat.d.ts

@@ -1,63 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ChildPart, noChange } from '../lit-html';
-import { Directive, PartInfo } from '../directive';
-export declare type KeyFn<T> = (item: T, index: number) => unknown;
-export declare type ItemTemplate<T> = (item: T, index: number) => unknown;
-declare class RepeatDirective extends Directive {
-    private _itemKeys?;
-    constructor(partInfo: PartInfo);
-    private _getValuesAndKeys;
-    render<T>(items: Iterable<T>, template: ItemTemplate<T>): Array<unknown>;
-    render<T>(items: Iterable<T>, keyFn: KeyFn<T> | ItemTemplate<T>, template: ItemTemplate<T>): Array<unknown>;
-    update<T>(containerPart: ChildPart, [items, keyFnOrTemplate, template]: [
-        Iterable<T>,
-        KeyFn<T> | ItemTemplate<T>,
-        ItemTemplate<T>
-    ]): any[] | typeof noChange;
-}
-export interface RepeatDirectiveFn {
-    <T>(items: Iterable<T>, keyFnOrTemplate: KeyFn<T> | ItemTemplate<T>, template?: ItemTemplate<T>): unknown;
-    <T>(items: Iterable<T>, template: ItemTemplate<T>): unknown;
-    <T>(items: Iterable<T>, keyFn: KeyFn<T> | ItemTemplate<T>, template: ItemTemplate<T>): unknown;
-}
-/**
- * A directive that repeats a series of values (usually `TemplateResults`)
- * generated from an iterable, and updates those items efficiently when the
- * iterable changes based on user-provided `keys` associated with each item.
- *
- * Note that if a `keyFn` is provided, strict key-to-DOM mapping is maintained,
- * meaning previous DOM for a given key is moved into the new position if
- * needed, and DOM will never be reused with values for different keys (new DOM
- * will always be created for new keys). This is generally the most efficient
- * way to use `repeat` since it performs minimum unnecessary work for insertions
- * and removals.
- *
- * The `keyFn` takes two parameters, the item and its index, and returns a unique key value.
- *
- * ```js
- * html`
- *   <ol>
- *     ${repeat(this.items, (item) => item.id, (item, index) => {
- *       return html`<li>${index}: ${item.name}</li>`;
- *     })}
- *   </ol>
- * `
- * ```
- *
- * **Important**: If providing a `keyFn`, keys *must* be unique for all items in a
- * given call to `repeat`. The behavior when two or more items have the same key
- * is undefined.
- *
- * If no `keyFn` is provided, this directive will perform similar to mapping
- * items to values, and DOM will be reused against potentially different items.
- */
-export declare const repeat: RepeatDirectiveFn;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { RepeatDirective };