@lushly-dev/fast-element 3.0.1-preview.0 → 3.0.1-preview.2

package/dist/dts/interfaces.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Represents a callable type such as a function or an object with a "call" method.
+ * @public
+ */
+export type Callable = typeof Function.prototype.call | {
+    call(): void;
+};
+/**
+ * Represents a type which can be constructed with the new operator.
+ *
+ * @public
+ */
+export type Constructable<T = {}> = {
+    new (...args: any[]): T;
+};
+/**
+ * Represents a constructable class with a prototype.
+ * @public
+ */
+export type Class<T, C = {}> = C & Constructable<T> & {
+    /**
+     * The class's prototype;
+     */
+    readonly prototype: T;
+};
+/**
+ * Provides a mechanism for releasing resources.
+ * @public
+ */
+export interface Disposable {
+    /**
+     * Disposes the resources.
+     */
+    dispose(): void;
+}
+/**
+ * A policy for use with the standard trustedTypes platform API.
+ * @public
+ */
+export type TrustedTypesPolicy = {
+    /**
+     * Creates trusted HTML.
+     * @param html - The HTML to clear as trustworthy.
+     */
+    createHTML(html: string): string;
+};
+/**
+ * Reverses all readonly members, making them mutable.
+ * @public
+ */
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * A temporary type as a workaround for the TS compiler's erroneous built-in ParameterDecorator type.
+ * @public
+ */
+export type ParameterDecorator = (target: Object, propertyKey: string | undefined, parameterIndex: number) => void;
+/**
+ * Warning and error messages.
+ * @internal
+ */
+export declare const enum Message {
+    needsArrayObservation = 1101,
+    onlySetDOMPolicyOnce = 1201,
+    bindingInnerHTMLRequiresTrustedTypes = 1202,
+    twoWayBindingRequiresObservables = 1203,
+    hostBindingWithoutHost = 1204,
+    unsupportedBindingBehavior = 1205,
+    directCallToHTMLTagNotAllowed = 1206,
+    onlySetTemplatePolicyOnce = 1207,
+    cannotSetTemplatePolicyAfterCompilation = 1208,
+    blockedByDOMPolicy = 1209,
+    invalidHydrationAttributeMarker = 1210,
+    duplicateRenderInstruction = 1211,
+    missingElementDefinition = 1401,
+    noRegistrationForContext = 1501,
+    noFactoryForResolver = 1502,
+    invalidResolverStrategy = 1503,
+    cannotAutoregisterDependency = 1504,
+    cannotResolveKey = 1505,
+    cannotConstructNativeFunction = 1506,
+    cannotJITRegisterNonConstructor = 1507,
+    cannotJITRegisterIntrinsic = 1508,
+    cannotJITRegisterInterface = 1509,
+    invalidResolver = 1510,
+    invalidKey = 1511,
+    noDefaultResolver = 1512,
+    cyclicDependency = 1513,
+    connectUpdateRequiresController = 1514
+}
+/**
+ * Determines whether or not an object is a function.
+ * @public
+ */
+export declare const isFunction: (object: any) => object is Function;
+/**
+ * Determines whether or not an object is a string.
+ * @public
+ */
+export declare const isString: (object: any) => object is string;
+/**
+ * A function which does nothing.
+ * @public
+ */
+export declare const noop: () => undefined;

package/dist/dts/metadata.d.ts

@@ -0,0 +1,26 @@
+import type { Constructable } from "./interfaces.js";
+/**
+ * Provides basic metadata capabilities used by Context and Dependency Injection.
+ * @public
+ */
+export declare const Metadata: Readonly<{
+    /**
+     * Gets the "design:paramtypes" metadata for the specified type.
+     * @param Type - The type to get the metadata for.
+     * @returns The metadata array or a frozen empty array if no metadata is found.
+     */
+    getDesignParamTypes: (Type: Constructable) => readonly any[];
+    /**
+     * Gets the "annotation:paramtypes" metadata for the specified type.
+     * @param Type - The type to get the metadata for.
+     * @returns The metadata array or a frozen empty array if no metadata is found.
+     */
+    getAnnotationParamTypes: (Type: Constructable) => readonly any[];
+    /**
+     * Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
+     * an empty, mutable metadata array is created and added.
+     * @param Type - The type to get or create the metadata for.
+     * @returns A mutable metadata array.
+     */
+    getOrCreateAnnotationParamTypes(Type: Constructable): any[];
+}>;

package/dist/dts/observation/arrays.d.ts

@@ -0,0 +1,248 @@
+import { type Subscriber, SubscriberSet } from "./notifier.js";
+/**
+ * A splice map is a representation of how a previous array of items
+ * was transformed into a new array of items. Conceptually it is a list of
+ * tuples of
+ *
+ *   (index, removed, addedCount)
+ *
+ * which are kept in ascending index order of. The tuple represents that at
+ * the |index|, |removed| sequence of items were removed, and counting forward
+ * from |index|, |addedCount| items were added.
+ * @public
+ */
+export declare class Splice {
+    index: number;
+    removed: any[];
+    addedCount: number;
+    /**
+     * Indicates that this splice represents a complete array reset.
+     */
+    reset?: boolean;
+    /**
+     * Creates a splice.
+     * @param index - The index that the splice occurs at.
+     * @param removed - The items that were removed.
+     * @param addedCount - The  number of items that were added.
+     */
+    constructor(index: number, removed: any[], addedCount: number);
+    /**
+     * Adjusts the splice index based on the provided array.
+     * @param array - The array to adjust to.
+     * @returns The same splice, mutated based on the reference array.
+     */
+    adjustTo(array: any[]): this;
+}
+/**
+ * A sort array indicates new index positions of array items.
+ * @public
+ */
+export declare class Sort {
+    sorted?: number[] | undefined;
+    /**
+     * Creates a sort update.
+     * @param sorted - The updated index of sorted items.
+     */
+    constructor(sorted?: number[] | undefined);
+}
+/**
+ * Indicates what level of feature support the splice
+ * strategy provides.
+ * @public
+ */
+export declare const SpliceStrategySupport: Readonly<{
+    /**
+     * Only supports resets.
+     */
+    readonly reset: 1;
+    /**
+     * Supports tracking splices and resets.
+     */
+    readonly splice: 2;
+    /**
+     * Supports tracking splices and resets, while applying some form
+     * of optimization, such as merging, to the splices.
+     */
+    readonly optimized: 3;
+}>;
+/**
+ * The available values for SpliceStrategySupport.
+ * @public
+ */
+export type SpliceStrategySupport = (typeof SpliceStrategySupport)[keyof typeof SpliceStrategySupport];
+/**
+ * An approach to tracking changes in an array.
+ * @public
+ */
+export interface SpliceStrategy {
+    /**
+     * The level of feature support the splice strategy provides.
+     */
+    readonly support: SpliceStrategySupport;
+    /**
+     * Normalizes the splices before delivery to array change subscribers.
+     * @param previous - The previous version of the array if a reset has taken place.
+     * @param current - The current version of the array.
+     * @param changes - The set of changes tracked against the array.
+     */
+    normalize(previous: unknown[] | undefined, current: unknown[], changes: Splice[] | undefined): readonly Splice[];
+    /**
+     * Performs and tracks a pop operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param pop - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    pop(array: any[], observer: ArrayObserver, pop: typeof Array.prototype.pop, args: any[]): any;
+    /**
+     * Performs and tracks a push operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param push - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    push(array: any[], observer: ArrayObserver, push: typeof Array.prototype.push, args: any[]): any;
+    /**
+     * Performs and tracks a reverse operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param reverse - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    reverse(array: any[], observer: ArrayObserver, reverse: typeof Array.prototype.reverse, args: any[]): any;
+    /**
+     * Performs and tracks a shift operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param shift - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    shift(array: any[], observer: ArrayObserver, shift: typeof Array.prototype.shift, args: any[]): any;
+    /**
+     * Performs and tracks a sort operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param sort - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    sort(array: any[], observer: ArrayObserver, sort: typeof Array.prototype.sort, args: any[]): any[];
+    /**
+     * Performs and tracks a splice operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param splice - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    splice(array: any[], observer: ArrayObserver, splice: typeof Array.prototype.splice, args: any[]): any;
+    /**
+     * Performs and tracks an unshift operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param unshift - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    unshift(array: any[], observer: ArrayObserver, unshift: typeof Array.prototype.unshift, args: any[]): any[];
+}
+/**
+ * Functionality related to tracking changes in arrays.
+ * @public
+ */
+export declare const SpliceStrategy: Readonly<{
+    /**
+     * A set of changes that represent a full array reset.
+     */
+    readonly reset: Splice[];
+    /**
+     * Sets the default strategy to use for array observers.
+     * @param strategy - The splice strategy to use.
+     */
+    readonly setDefaultStrategy: (strategy: SpliceStrategy) => void;
+}>;
+/**
+ * Observes array lengths.
+ * @public
+ */
+export interface LengthObserver extends Subscriber {
+    /**
+     * The length of the observed array.
+     */
+    length: number;
+}
+/**
+ * Observes array sort.
+ * @public
+ */
+export interface SortObserver extends Subscriber {
+    /**
+     * The sorted times on the observed array, this should be incremented every time
+     * an item in the array changes location.
+     */
+    sorted: number;
+}
+/**
+ * An observer for arrays.
+ * @public
+ */
+export interface ArrayObserver extends SubscriberSet {
+    /**
+     * The strategy to use for tracking changes.
+     */
+    strategy: SpliceStrategy | null;
+    /**
+     * The length observer for the array.
+     */
+    readonly lengthObserver: LengthObserver;
+    /**
+     * The sort observer for the array.
+     */
+    readonly sortObserver: SortObserver;
+    /**
+     * Adds a splice to the list of changes.
+     * @param splice - The splice to add.
+     */
+    addSplice(splice: Splice): void;
+    /**
+     * Adds a sort to the list of changes.
+     * @param sort - The sort to add.
+     */
+    addSort(sort: Sort): void;
+    /**
+     * Indicates that a reset change has occurred.
+     * @param oldCollection - The collection as it was before the reset.
+     */
+    reset(oldCollection: any[] | undefined): void;
+    /**
+     * Flushes the changes to subscribers.
+     */
+    flush(): void;
+}
+/**
+ * An observer for arrays.
+ * @public
+ */
+export declare const ArrayObserver: Readonly<{
+    readonly sorted: 0;
+    /**
+     * Enables the array observation mechanism.
+     * @remarks
+     * Array observation is enabled automatically when using the
+     * `RepeatDirective`, so calling this API manually is
+     * not typically necessary.
+     */
+    readonly enable: () => void;
+}>;
+/**
+ * Enables observing the length of an array.
+ * @param array - The array to observe the length of.
+ * @returns The length of the array.
+ * @public
+ */
+export declare function lengthOf<T>(array: readonly T[]): number;
+/**
+ * Enables observing the sorted property of an array.
+ * @param array - The array to observe the sorted property of.
+ * @returns The sorted property.
+ * @public
+ */
+export declare function sortedCount<T>(array: readonly T[]): number;
+export { type Notifier, type Subscriber, SubscriberSet } from "./notifier.js";

package/dist/dts/observation/notifier.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Implemented by objects that are interested in change notifications.
+ * @public
+ */
+export interface Subscriber {
+    /**
+     * Called when a subject this instance has subscribed to changes.
+     * @param subject - The subject of the change.
+     * @param args - The event args detailing the change that occurred.
+     */
+    handleChange(subject: any, args: any): void;
+}
+/**
+ * Provides change notifications for an observed subject.
+ * @public
+ */
+export interface Notifier {
+    /**
+     * The object that subscribers will receive notifications for.
+     */
+    readonly subject: any;
+    /**
+     * Notifies all subscribers, based on the args.
+     * @param args - Data passed along to subscribers during notification.
+     * @remarks
+     * In some implementations, the args may be used to target specific subscribers.
+     * This is usually in the case where a propertyName was passed during subscription.
+     */
+    notify(args: any): void;
+    /**
+     * Subscribes to notification of changes in an object's state.
+     * @param subscriber - The object that is subscribing for change notification.
+     * @param propertyToWatch - The name of the property that the subscriber is interested in watching for changes.
+     * @remarks
+     * Some implementation may or may not require the propertyToWatch.
+     */
+    subscribe(subscriber: Subscriber, propertyToWatch?: any): void;
+    /**
+     * Unsubscribes from notification of changes in an object's state.
+     * @param subscriber - The object that is unsubscribing from change notification.
+     * @param propertyToUnwatch - The name of the property that the subscriber is no longer interested in watching.
+     * @remarks
+     * Some implementation may or may not require the propertyToUnwatch.
+     */
+    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
+}
+/**
+ * An implementation of {@link Notifier} that efficiently keeps track of
+ * subscribers interested in a specific change notification on an
+ * observable subject.
+ *
+ * @remarks
+ * This set is optimized for the most common scenario of 1 or 2 subscribers.
+ * With this in mind, it can store a subscriber in an internal field, allowing it to avoid Array#push operations.
+ * If the set ever exceeds two subscribers, it upgrades to an array automatically.
+ * @public
+ */
+export declare class SubscriberSet implements Notifier {
+    private sub1;
+    private sub2;
+    private spillover;
+    /**
+     * The object that subscribers will receive notifications for.
+     */
+    readonly subject: any;
+    /**
+     * Creates an instance of SubscriberSet for the specified subject.
+     * @param subject - The subject that subscribers will receive notifications from.
+     * @param initialSubscriber - An initial subscriber to changes.
+     */
+    constructor(subject: any, initialSubscriber?: Subscriber);
+    /**
+     * Checks whether the provided subscriber has been added to this set.
+     * @param subscriber - The subscriber to test for inclusion in this set.
+     */
+    has(subscriber: Subscriber): boolean;
+    /**
+     * Subscribes to notification of changes in an object's state.
+     * @param subscriber - The object that is subscribing for change notification.
+     */
+    subscribe(subscriber: Subscriber): void;
+    /**
+     * Unsubscribes from notification of changes in an object's state.
+     * @param subscriber - The object that is unsubscribing from change notification.
+     */
+    unsubscribe(subscriber: Subscriber): void;
+    /**
+     * Notifies all subscribers.
+     * @param args - Data passed along to subscribers during notification.
+     */
+    notify(args: any): void;
+}
+/**
+ * An implementation of Notifier that allows subscribers to be notified
+ * of individual property changes on an object.
+ * @public
+ */
+export declare class PropertyChangeNotifier implements Notifier {
+    private subscribers;
+    private subjectSubscribers;
+    /**
+     * The subject that property changes are being notified for.
+     */
+    readonly subject: any;
+    /**
+     * Creates an instance of PropertyChangeNotifier for the specified subject.
+     * @param subject - The object that subscribers will receive notifications for.
+     */
+    constructor(subject: any);
+    /**
+     * Notifies all subscribers, based on the specified property.
+     * @param propertyName - The property name, passed along to subscribers during notification.
+     */
+    notify(propertyName: string): void;
+    /**
+     * Subscribes to notification of changes in an object's state.
+     * @param subscriber - The object that is subscribing for change notification.
+     * @param propertyToWatch - The name of the property that the subscriber is interested in watching for changes.
+     */
+    subscribe(subscriber: Subscriber, propertyToWatch?: string): void;
+    /**
+     * Unsubscribes from notification of changes in an object's state.
+     * @param subscriber - The object that is unsubscribing from change notification.
+     * @param propertyToUnwatch - The name of the property that the subscriber is no longer interested in watching.
+     */
+    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: string): void;
+}