@genesislcap/web-core 14.157.0

package/dist/dts/patterns/tag-for.d.ts

@@ -0,0 +1,21 @@
+import { Constructable, FASTElement, FASTElementDefinition } from '@microsoft/fast-element';
+/**
+ * Used to designate a template's dependency on another custom element.
+ * @beta
+ */
+export type TemplateElementDependency = string | FASTElementDefinition | Constructable<FASTElement>;
+/**
+ * Used to help map components / elements for tagFor usage
+ * @beta
+ */
+export type TemplateElements = {
+    [key: string]: TemplateElementDependency;
+};
+/**
+ * Determines what HTML tag name to use for the dependency.
+ * @param dependency - The dependency the template is dependent on.
+ * @returns The tag name to use in markup.
+ * @beta
+ */
+export declare function tagFor(dependency: TemplateElementDependency): string;
+//# sourceMappingURL=tag-for.d.ts.map

package/dist/dts/patterns/tag-for.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-for.d.ts","sourceRoot":"","sources":["../../../src/patterns/tag-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAE5F;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,qBAAqB,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;AAEpG;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAAA;CAAE,CAAC;AAE5E;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,yBAAyB,GAAG,MAAM,CAcpE"}

package/dist/dts/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.34.9"
+    }
+  ]
+}

package/dist/esm/FAST/fast-colors.js

@@ -0,0 +1 @@
+export { ColorRGBA64, ComponentStateColorPalette, parseColorHexRGB } from '@microsoft/fast-colors';

package/dist/esm/FAST/fast-components.js

@@ -0,0 +1 @@
+export * from '@microsoft/fast-components';

package/dist/esm/FAST/fast-element.js

@@ -0,0 +1 @@
+export { attr, BindingBehavior, children, css, CSSDirective, cssPartial, customElement, defaultExecutionContext, DOM, elements, ElementStyles, ExecutionContext, FASTElement, FASTElementDefinition, html, HTMLBindingDirective, HTMLView, nullableNumberConverter, Observable, observable, ref, repeat, slotted, ViewTemplate, volatile, when, } from '@microsoft/fast-element';

package/dist/esm/FAST/fast-foundation.js

@@ -0,0 +1 @@
+export { accordionItemTemplate, accordionTemplate, anchorTemplate, anchoredRegionTemplate, avatarTemplate, badgeTemplate, breadcrumbItemTemplate, breadcrumbTemplate, buttonTemplate, calendarTemplate, cardTemplate, checkboxTemplate, composedParent, ComboboxAutocomplete, Container, dataGridTemplate, dataGridCellTemplate, dataGridRowTemplate, DesignSystem, DesignToken, DI, disclosureTemplate, display, dividerTemplate, endSlotTemplate, flipperTemplate, FoundationElement, FoundationElementRegistry, forcedColorsStylesheetBehavior, FormAssociated, horizontalScrollTemplate, inject, listboxTemplate, listboxOptionTemplate, menuTemplate, menuItemTemplate, optional, progressTemplate, progressRingTemplate, PropertyStyleSheetBehavior, Registration, radioTemplate, radioGroupTemplate, selectTemplate, skeletonTemplate, sliderLabelTemplate, startSlotTemplate, switchTemplate, tabTemplate, tabPanelTemplate, tabsTemplate, TabsOrientation, textAreaTemplate, toolbarTemplate, TooltipPosition, tooltipTemplate, treeItemTemplate, treeViewTemplate, whitespaceFilter, } from '@microsoft/fast-foundation';

package/dist/esm/FAST/fast-router.js

@@ -0,0 +1 @@
+export { DefaultRouteRecognizer, FASTElementLayout, FASTRouter, Route, RouteCollection, Router, RouterConfiguration, } from '@microsoft/fast-router';

package/dist/esm/FAST/fast-web-utilities.js

@@ -0,0 +1 @@
+export { classNames, Direction, limit, Orientation, pascalCase, SystemColors, uniqueId, } from '@microsoft/fast-web-utilities';

package/dist/esm/FAST/index.js

@@ -0,0 +1,6 @@
+export * from './fast-colors';
+export * from './fast-components';
+export * from './fast-element';
+export * from './fast-foundation';
+export * from './fast-router';
+export * from './fast-web-utilities';

package/dist/esm/directives/index.js

@@ -0,0 +1,2 @@
+export * from './sync';
+export * from './when-else';

package/dist/esm/directives/sync.js

@@ -0,0 +1,97 @@
+import { HTMLBindingDirective, } from '@microsoft/fast-element';
+/**
+ * A map that associates specific HTML element tags with their corresponding default event names.
+ * @public
+ */
+export const defaultEventMap = new Map([
+    ['FAST-TEXT-AREA', 'input'],
+    ['FAST-TEXT-FIELD', 'input'],
+    ['FOUNDATION-TEXT-AREA', 'input'],
+    ['FOUNDATION-TEXT-FIELD', 'input'],
+    ['INPUT', 'input'],
+    ['ZERO-TEXT-FIELD', 'input'],
+]);
+function customUpdateTarget(value) {
+    if (this['keyAttr']) {
+        // FUI-389: set initial state based on keyAttr
+    }
+    else {
+        this.target[this.targetName] = value;
+    }
+}
+function bind(source, context) {
+    if (this['keyAttr']) {
+        // overwrite internal update method called by originalBind
+        this.updateTarget = customUpdateTarget;
+    }
+    this.originalBind.call(this, source, context);
+    this.target.addEventListener(this.changeEvent, this.changeHandler);
+}
+function unbind() {
+    this.originalUnbind.call(this);
+    this.target.removeEventListener(this.changeEvent, this.changeHandler);
+}
+function determineChangeEvent(target, eventName) {
+    var _a;
+    const tag = target.tagName;
+    if (eventName === 'default') {
+        return (_a = defaultEventMap.get(tag)) !== null && _a !== void 0 ? _a : 'change';
+    }
+    return eventName;
+}
+class SyncDirective extends HTMLBindingDirective {
+    constructor(binding, convert, eventName, keyAttr) {
+        super(binding);
+        this.keyAttr = keyAttr;
+        this.conversionType = convert;
+        this.eventName = eventName;
+    }
+    createBehavior(target) {
+        const behavior = super.createBehavior(target);
+        behavior.originalBind = behavior.bind;
+        behavior.originalUnbind = behavior.unbind;
+        behavior.keyAttr = this.keyAttr;
+        behavior.bind = bind;
+        behavior.unbind = unbind;
+        behavior.changeEvent = determineChangeEvent(target, this.eventName);
+        behavior.changeHandler = () => {
+            // for checkbox, which is currently the only component converting to boolean, will have to change if boolean conversion is used anywhere else
+            const value = this.conversionType === 'boolean' ? behavior.target.checked : behavior.target.value;
+            if (this.keyAttr) {
+                const last = behavior.bindingObserver.last;
+                const key = behavior.target[this.keyAttr];
+                last.propertySource[last.propertyName][key] = this.convert(value);
+            }
+            else {
+                // Wait for an official setValue API
+                const last = behavior.bindingObserver.last;
+                last.propertySource[last.propertyName] = this.convert(value);
+            }
+        };
+        return behavior;
+    }
+    convert(value) {
+        if (value === undefined || value === null)
+            return value;
+        switch (this.conversionType) {
+            case 'time':
+                const msSinceEpoch = new Date(value).getTime();
+                return isNaN(msSinceEpoch) ? undefined : msSinceEpoch;
+            case 'number':
+                return value.length ? Number(value) : undefined; // Number('') returns 0
+            case 'string':
+                return String(value);
+            case 'boolean':
+                return Boolean(value);
+            default:
+                return value;
+        }
+    }
+}
+/**
+ * Creates a synchronization directive that binds a data source to an HTML element,
+ * @public
+ */
+export function sync(binding, conversionType = 'string', eventName = 'default', keyAttr) {
+    return new SyncDirective(binding, conversionType, eventName, keyAttr);
+}

package/dist/esm/directives/when-else.js

@@ -0,0 +1,14 @@
+/**
+ * Directive that allows supplying an "else" template to the traditional {@link https://www.fast.design/docs/api/fast-element.when/#when-function} directive
+ *
+ * @param binding - The condition to test for rendering.
+ * @param trueTemplateOrTemplateBinding - The template or a binding that gets the template to render when the condition is true.
+ * @param falseTemplateOrTemplateBinding - The template or a binding that gets the template to render when the condition is false.
+ * @public
+ */
+export function whenElse(binding, trueTemplateOrTemplateBinding, falseTemplateOrTemplateBinding) {
+    const getTemplate = (template) => typeof template === 'function' ? template : () => template;
+    const trueTemplate = getTemplate(trueTemplateOrTemplateBinding);
+    const falseTemplate = getTemplate(falseTemplateOrTemplateBinding);
+    return (source, context) => binding(source, context) ? trueTemplate(source, context) : falseTemplate(source, context);
+}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from './directives';
+export * from './FAST';
+export * from './patterns';

package/dist/esm/patterns/define.js

@@ -0,0 +1,37 @@
+import { FASTElement } from '@microsoft/fast-element';
+const defaultDefinitionOverrider = (base) => (override) => (Object.assign(Object.assign({}, base), override));
+/**
+ * Defines a platform custom element based on the provided type and definition.
+ *
+ * @example
+ * An example using custom definition merge logic, useful if you need to impose hard restrictions.
+ * ```ts
+ * const definitionOverrider = (definition) => ({
+ *    ...baseDefinition,
+ *    ...definition,
+ *    styles: baseDefinition.styles,
+ *    shadowOptions: {
+ *      mode: 'closed,
+ *    },
+ * });
+ * export const define = defineFactory(LoginForm, definitionOverrider);
+ * ```
+ *
+ * @example
+ * You can provide the base definition if you're happy with the default spread operator merge logic.
+ * ```ts
+ * export const define = defineFactory(LoginForm, baseDefinition);
+ * ```
+ *
+ * @param Type - The custom element Type / Class to define.
+ * @param overriderOrBase - A function that merges definitions, or the base definition if custom merging is not needed.
+ * @returns The type class.
+ * @beta
+ */
+export const defineFactory = (Type, overriderOrBase) => (definition) => {
+    const overrider = typeof overriderOrBase === 'function'
+        ? overriderOrBase
+        : defaultDefinitionOverrider(overriderOrBase);
+    return FASTElement.define(class extends Type {
+    }, overrider(definition));
+};

package/dist/esm/patterns/index.js

@@ -0,0 +1,2 @@
+export * from './define';
+export * from './tag-for';

package/dist/esm/patterns/tag-for.js

@@ -0,0 +1,20 @@
+import { FASTElementDefinition } from '@microsoft/fast-element';
+/**
+ * Determines what HTML tag name to use for the dependency.
+ * @param dependency - The dependency the template is dependent on.
+ * @returns The tag name to use in markup.
+ * @beta
+ */
+export function tagFor(dependency) {
+    if (typeof dependency === 'string') {
+        return dependency;
+    }
+    if (typeof dependency === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        dependency = FASTElementDefinition.forType(dependency); // < using forType instead of getByType for now...
+        if (!dependency) {
+            throw new Error('Missing FASTElement definition.');
+        }
+    }
+    return dependency.name;
+}