@microsoft/fast-html 1.0.0-alpha.19 → 1.0.0-alpha.20

package/dist/fast-html.untrimmed.d.ts

@@ -2,36 +2,22 @@ import { Constructable } from '@microsoft/fast-element';
 import { FASTElement } from '@microsoft/fast-element';
 import { ShadowRootOptions } from '@microsoft/fast-element';
 
-declare interface AccessCachedPath {
+declare interface AccessCachedPath extends CachedPathCommon {
     type: AccessCachedPathType;
-    relativePath: string;
-    absolutePath: string;
 }
 
 declare type AccessCachedPathType = "access";
 
 declare type CachedPath = DefaultCachedPath | RepeatCachedPath | AccessCachedPath | EventCachedPath;
 
-declare type CachedPathMap = Record<string, CachedPath>;
-
-declare interface ContextCache {
-    /**
-     * The path to this context
-     */
-    absolutePath: string;
-    /**
-     * The self string of that context
-     */
-    context: string;
-    /**
-     * The parent of this context
-     */
-    parent: string | null;
+declare interface CachedPathCommon {
+    parentContext: string | null;
+    currentContext: string | null;
+    path: string;
 }
 
-declare interface DefaultCachedPath {
+declare interface DefaultCachedPath extends CachedPathCommon {
     type: DefaultCachedPathType;
-    paths: Record<string, CachedPath>;
 }
 
 declare type DefaultCachedPathType = "default";
@@ -48,128 +34,38 @@ declare interface ElementOptionsDictionary<ElementOptionsType = ElementOptions>
     [key: string]: ElementOptionsType;
 }
 
-declare interface EventCachedPath {
+declare interface EventCachedPath extends CachedPathCommon {
     type: EventCachedPathType;
-    relativePath: string;
-    absolutePath: string;
 }
 
 declare type EventCachedPathType = "event";
 
+declare interface JSONSchema extends JSONSchemaCommon {
+    $schema: string;
+    $id: string;
+    $defs?: Record<string, JSONSchemaDefinition>;
+    $ref?: string;
+}
+
+declare interface JSONSchemaCommon {
+    type?: string;
+    properties?: any;
+    items?: any;
+}
+
+declare interface JSONSchemaDefinition extends JSONSchemaCommon {
+    $fast_context: string;
+    $fast_parent_contexts: Array<string>;
+}
+
 /**
  * ObserverMap provides functionality for caching binding paths, extracting root properties,
  * and defining observable properties on class prototypes
  */
 export declare class ObserverMap {
-    private cachePaths;
-    private contextCache;
+    private schema;
     private classPrototype;
-    constructor(classPrototype: any);
-    private getRootProperty;
-    /**
-     * Caches a binding path with context information for later use in generating observable properties
-     * @param context - The path context information containing path, self, parentContext, contextPath, type, and level
-     */
-    cachePathWithContext(config: PathConfig): void;
-    /**
-     * Handles caching of paths with relative navigation ("../")
-     * Determines the correct context level and caches the path accordingly
-     */
-    private handleRelativePathCaching;
-    /**
-     * Counts the number of "../" sequences in a path without using regex
-     */
-    private countRelativeNavigationLevels;
-    /**
-     * Extracts the property name from a relative path, removing all "../" sequences
-     */
-    private extractPropertyNameFromRelativePath;
-    /**
-     * Determines the target context after navigating up the specified number of levels
-     */
-    private getTargetContextForRelativePath;
-    /**
-     * Caches a path at the root level
-     */
-    private cacheAtRootLevel;
-    /**
-     * Caches a path at a specific context level
-     */
-    private cacheAtContextLevel;
-    /**
-     * Handles caching of access-type paths (property bindings)
-     */
-    private handleAccessPath;
-    /**
-     * Handles caching of repeat-type paths (array/loop contexts)
-     */
-    private handleRepeatPath;
-    /**
-     * Caches a simple access path without context complexity
-     */
-    private cacheSimpleAccessPath;
-    /**
-     * Finds a context item in the temporary context cache
-     */
-    private findContextInCache;
-    /**
-     * Attempts to place an access path under an existing repeat structure
-     * @returns true if successfully placed, false otherwise
-     */
-    private tryPlaceInExistingRepeat;
-    /**
-     * Recursively searches for and places access paths in matching repeat structures
-     */
-    private searchAndPlaceInRepeat;
-    /**
-     * Checks if a cached path is a repeat structure with matching context
-     */
-    private isMatchingRepeatStructure;
-    /**
-     * Determines if a cached path can be searched for nested structures
-     */
-    private canSearchNested;
-    /**
-     * Places an access path within an existing repeat structure
-     */
-    private placeAccessInRepeat;
-    /**
-     * Builds absolute paths for nested repeat access patterns
-     * @example "root.items.__index__.subitems.__index__.title"
-     */
-    private buildNestedRepeatAbsolutePath;
-    /**
-     * Caches access paths that have context information
-     */
-    private cacheAccessPathWithContext;
-    /**
-     * Extracts the relative path from a context's absolute path
-     * For nested contexts, this should match the cache structure path
-     */
-    private getRelativeContextPath;
-    /**
-     * Ensures a repeat structure exists in the cache
-     */
-    private ensureRepeatStructureExists;
-    /**
-     * Creates the cache structure for nested repeat patterns
-     */
-    private createNestedRepeatStructure;
-    /**
-     * Finds the cache path where a parent context's repeat structure is located
-     */
-    private findParentRepeatPath;
-    getCachedPathsWithContext(): CachedPathMap;
-    private resolveContextPath;
-    private resolveRootAndContextPath;
-    getAbsolutePath(config: PathConfig): string;
-    /**
-     * Builds the full context path by looking up parent contexts in contextCache
-     * @param parentContext - The immediate parent context to start from
-     * @param contextPath - The current context path (like "items")
-     * @returns The full absolute path including all parent contexts
-     */
-    private getPathFromCachedContext;
+    constructor(classPrototype: any, schema: Schema);
     defineProperties(): void;
     /**
      * Creates a proxy for an object that intercepts property mutations and triggers Observable notifications
@@ -190,19 +86,11 @@ export declare class ObserverMap {
 
 declare type ObserverMapOption = "all";
 
-declare interface PathConfig {
-    path: string;
-    self: boolean;
-    parentContext: string | null;
-    contextPath: string | null;
-    type: PathType;
-    level: number;
-    rootPath: string | null;
-    context: ContextCache | null;
+declare interface RegisterPathConfig {
+    rootPropertyName: string;
+    pathConfig: CachedPath;
 }
 
-declare type PathType = "access" | "default" | "event" | "repeat";
-
 /**
  * A mixin function that extends a base class with additional functionality for
  * rendering and hydration.
@@ -213,14 +101,98 @@ declare type PathType = "access" | "default" | "event" | "repeat";
  */
 export declare function RenderableFASTElement<T extends Constructable<FASTElement>>(BaseCtor: T): T;
 
-declare interface RepeatCachedPath {
+declare interface RepeatCachedPath extends CachedPathCommon {
     type: RepeatCachedPathType;
-    context: string;
-    paths: Record<string, CachedPath>;
 }
 
 declare type RepeatCachedPathType = "repeat";
 
+/**
+ * A constructed JSON schema from a template
+ */
+declare class Schema {
+    /**
+     * The name of the custom element
+     */
+    private customElementName;
+    /**
+     * A JSON schema describing each root schema
+     */
+    private jsonSchemaMap;
+    constructor(name: string);
+    /**
+     * Add a path to a schema
+     * @param config RegisterPathConfig
+     */
+    addPath(config: RegisterPathConfig): void;
+    /**
+     * Gets the JSON schema for a property name
+     * @param rootPropertyName - the root property the JSON schema is mapped to
+     * @returns The JSON schema for the root property
+     */
+    getSchema(rootPropertyName: string): JSONSchema | null;
+    /**
+     * Gets root properties
+     * @returns IterableIterator<string>
+     */
+    getRootProperties(): IterableIterator<string>;
+    /**
+     * Get a path split into property names
+     * @param path The dot syntax path e.g. a.b.c
+     * @returns An array of items in the path
+     */
+    private getSplitPath;
+    /**
+     * Gets the path to the $def
+     * @param context The context name e.g. {{item in items}} in a repeat creates the "item" context
+     * @returns A string to use as a $ref
+     */
+    private getDefsPath;
+    /**
+     * Add a new JSON schema to the JSON schema map
+     * @param propertyName The name of the property to assign this JSON schema to
+     */
+    private addNewSchema;
+    /**
+     * Add properties to a context
+     * @param schema The schema to add the properties to
+     * @param splitPath The path split into property/context names
+     * @param context The paths context
+     */
+    private addPropertiesToAContext;
+    /**
+     * Add properties to an object
+     * @param schema The schema to add the properties to
+     * @param splitPath The path split into property/context names
+     * @param context The paths context
+     * @param type The data type (see JSON schema for details)
+     */
+    private addPropertiesToAnObject;
+    /**
+     * Add an array to an object property
+     * @param schema The schema to add the properties to
+     * @param context The name of the context
+     */
+    private addArrayToAnObject;
+    /**
+     * Add a context to the $defs property
+     * @param schema The schema to use
+     * @param propertyName The name of the property the context belongs to
+     * @param currentContext The current context
+     * @param parentContext The parent context
+     * @returns
+     */
+    private addContext;
+    /**
+     * Get parent contexts
+     * @param schema The schema to use
+     * @param parentContext The parent context
+     * @param contexts A list of parent contexts
+     * @returns
+     */
+    private getParentContexts;
+}
+
 /**
  * The <f-template> custom element that will provide view logic to the element
  */
@@ -238,6 +210,7 @@ export declare class TemplateElement extends FASTElement {
      * ObserverMap instance for caching binding paths
      */
     private observerMap?;
+    private schema?;
     private static defaultElementOptions;
     static options(elementOptions?: ElementOptionsDictionary): typeof TemplateElement;
     constructor();
@@ -295,11 +268,6 @@ export declare class TemplateElement extends FASTElement {
      * @param observerMap - ObserverMap instance for caching binding paths (optional).
      */
     private resolveInnerHTML;
-    /**
-     * Resolve all partial templates
-     * @param unresolvedInnerHTML - The innerHTML.
-     */
-    private resolveAllPartials;
 }
 
 export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/fast-html",
-  "version": "1.0.0-alpha.19",
+  "version": "1.0.0-alpha.20",
   "type": "module",
   "author": {
     "name": "Microsoft",
@@ -29,13 +29,12 @@
     "build:binding": "webpack --config ./src/fixtures/binding/webpack.config.js",
     "build:children": "webpack --config ./src/fixtures/children/webpack.config.js",
     "build:dot-syntax": "webpack --config ./src/fixtures/dot-syntax/webpack.config.js",
-    "build:partial": "webpack --config ./src/fixtures/partial/webpack.config.js",
     "build:when": "webpack --config ./src/fixtures/when/webpack.config.js",
     "build:ref": "webpack --config ./src/fixtures/ref/webpack.config.js",
     "build:repeat": "webpack --config ./src/fixtures/repeat/webpack.config.js",
     "build:observer-map": "webpack --config ./src/fixtures/observer-map/webpack.config.js",
     "build:slotted": "webpack --config ./src/fixtures/slotted/webpack.config.js",
-    "build-app": "npm run build:attribute && npm run build:dot-syntax && npm run build:partial && npm run build:event && npm run build:children && npm run build:binding && npm run build:when && npm run build:ref && npm run build:repeat && npm run build:observer-map && npm run build:slotted",
+    "build-app": "npm run build:attribute && npm run build:dot-syntax && npm run build:event && npm run build:children && npm run build:binding && npm run build:when && npm run build:ref && npm run build:repeat && npm run build:observer-map && npm run build:slotted",
     "build-server": "tsc -b server",
     "doc": "api-extractor run --local",
     "doc:ci": "api-extractor run",

package/dist/dts/fixtures/partial/main.d.ts

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

package/dist/dts/fixtures/partial/partial.spec.d.ts

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

package/dist/esm/fixtures/partial/main.js

@@ -1,32 +0,0 @@
-import { FASTElement } from "@microsoft/fast-element";
-import { RenderableFASTElement, TemplateElement } from "@microsoft/fast-html";
-class TestElement extends FASTElement {
-    constructor() {
-        super(...arguments);
-        this.items = [
-            {
-                text: "Hello",
-            },
-            {
-                text: "Earth",
-                items: [
-                    {
-                        text: "Pluto",
-                        items: [
-                            {
-                                text: "Mars",
-                            },
-                        ],
-                    },
-                ],
-            },
-        ];
-    }
-}
-RenderableFASTElement(TestElement).defineAsync({
-    name: "test-element",
-    templateOptions: "defer-and-hydrate",
-});
-TemplateElement.define({
-    name: "f-template",
-});

package/dist/esm/fixtures/partial/partial.spec.js

@@ -1,14 +0,0 @@
-import { __awaiter } from "tslib";
-import { expect, test } from "@playwright/test";
-test.describe("f-template", () => __awaiter(void 0, void 0, void 0, function* () {
-    test("create a partial", ({ page }) => __awaiter(void 0, void 0, void 0, function* () {
-        yield page.goto("/partial");
-        const customElement = yield page.locator("#test");
-        let customElementListItems = yield customElement.locator("li");
-        expect(yield customElementListItems.count()).toEqual(4);
-        expect(yield customElementListItems.nth(0).textContent()).toEqual("Hello");
-        expect(yield customElementListItems.nth(1).textContent()).toContain("Earth");
-        expect(yield customElementListItems.nth(2).textContent()).toContain("Pluto");
-        expect(yield customElementListItems.nth(3).textContent()).toContain("Mars");
-    }));
-}));