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

package/README.md

@@ -187,32 +187,16 @@ Where the right operand can be either a reference to a value (string e.g. `{{foo
     <ul><f-repeat value="{{item in list}}"><li>{{item}}</li></f-repeat></ul>
     ```
 
-    Should you need to refer to the parent element (not the individual item in the list), you can use `../`. This will map to what `html` tag template literal uses, `c.parent`.
+    Should you need to refer to the parent element (not the individual item in the list), you can use the context of a previous repeat, or no context which will resolve to the custom element.
 
     Example:
     ```html
-    <ul><f-repeat value="{{item in list}}"><li>{{item}} - {{../title}}</li></f-repeat></ul>
-    ```
-
-- **partial & apply**
-
-    These directives are new to the declarative HTML model and allow for the ability to declare a `partial` directive containing a template partial which can then be referenced by an `apply` directive.
-
-    Example:
-    ```html
-    <f-partial id="test">
-        <ul>
-            <f-repeat value="{{item in items}}">
-                <li>{{item.text}}<f-apply partial="test" value="{{item.items}}"></f-apply></li>
-            </f-repeat>
-        </ul>
-    </f-partial>
-    <f-apply partial="test" value="{{items}}"></f-apply>
+    <ul><f-repeat value="{{item in list}}"><li>{{item}} - {{title}}</li></f-repeat></ul>
     ```
 
 #### Unescaped HTML
 
-You can add unescaped HTML using triple braces, this will create an additional `div` element as the HTML needs an element to bind to. Where possible it is advisable to not use unescaped HTML and instead use other binding techniques as well as partials.
+You can add unescaped HTML using triple braces, this will create an additional `div` element as the HTML needs an element to bind to. Where possible it is advisable to not use unescaped HTML and instead use other binding techniques.
 
 Example:
 ```html

package/dist/dts/components/observer-map.d.ts

@@ -1,128 +1,12 @@
-import type { CachedPathMap, ContextCache, PathType } from "./utilities.js";
-interface PathConfig {
-    path: string;
-    self: boolean;
-    parentContext: string | null;
-    contextPath: string | null;
-    type: PathType;
-    level: number;
-    rootPath: string | null;
-    context: ContextCache | null;
-}
+import { Schema } from "./schema.js";
 /**
  * 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
@@ -140,4 +24,3 @@ export declare class ObserverMap {
      */
     private defineChanged;
 }
-export {};

package/dist/dts/components/schema.d.ts

@@ -1,41 +1,40 @@
-interface JSONSchemaDefinition extends JSONSchemaCommon {
+type FastContextMetaData = "$fast_context";
+type FastContextsMetaData = "$fast_parent_contexts";
+export interface JSONSchemaDefinition extends JSONSchemaCommon {
     $fast_context: string;
     $fast_parent_contexts: Array<string>;
 }
 interface JSONSchemaCommon {
     type?: string;
     properties?: any;
+    items?: any;
 }
-interface JSONSchema extends JSONSchemaCommon {
+export interface JSONSchema extends JSONSchemaCommon {
     $schema: string;
     $id: string;
     $defs?: Record<string, JSONSchemaDefinition>;
     $ref?: string;
 }
-type AccessCachedPathType = "access";
-export interface AccessCachedPath {
-    type: AccessCachedPathType;
+interface CachedPathCommon {
+    parentContext: string | null;
     currentContext: string | null;
     path: string;
 }
+type AccessCachedPathType = "access";
+export interface AccessCachedPath extends CachedPathCommon {
+    type: AccessCachedPathType;
+}
 type DefaultCachedPathType = "default";
-export interface DefaultCachedPath {
+export interface DefaultCachedPath extends CachedPathCommon {
     type: DefaultCachedPathType;
-    currentContext: string | null;
-    path: string;
 }
 type EventCachedPathType = "event";
-export interface EventCachedPath {
+export interface EventCachedPath extends CachedPathCommon {
     type: EventCachedPathType;
-    currentContext: string | null;
-    path: string;
 }
 type RepeatCachedPathType = "repeat";
-export interface RepeatCachedPath {
+export interface RepeatCachedPath extends CachedPathCommon {
     type: RepeatCachedPathType;
-    parentContext: string | null;
-    currentContext: string;
-    path: string;
 }
 export type CachedPath = DefaultCachedPath | RepeatCachedPath | AccessCachedPath | EventCachedPath;
 export type CachedPathMap = Map<string, JSONSchema>;
@@ -43,6 +42,10 @@ interface RegisterPathConfig {
     rootPropertyName: string;
     pathConfig: CachedPath;
 }
+export declare const fastContextMetaData: FastContextMetaData;
+export declare const fastContextsMetaData: FastContextsMetaData;
+export declare const defsPropertyName = "$defs";
+export declare const refPropertyName = "$ref";
 /**
  * A constructed JSON schema from a template
  */
@@ -67,6 +70,11 @@ export declare class Schema {
      * @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

package/dist/dts/components/template.d.ts

@@ -28,6 +28,7 @@ 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();
@@ -85,10 +86,5 @@ 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 { TemplateElement };

package/dist/dts/components/utilities.d.ts

@@ -1,6 +1,6 @@
-import { type ObserverMap } from "./observer-map.js";
+import { JSONSchema, JSONSchemaDefinition, Schema } from "./schema.js";
 type BehaviorType = "dataBinding" | "templateDirective";
-type TemplateDirective = "when" | "repeat" | "apply";
+type TemplateDirective = "when" | "repeat";
 export type AttributeDirective = "children" | "slotted" | "ref";
 type DataBindingBindingType = "client" | "default" | "unescaped";
 interface BehaviorConfig {
@@ -36,50 +36,6 @@ export interface TemplateDirectiveBehaviorConfig extends BehaviorConfig {
     closingTagStartIndex: number;
     closingTagEndIndex: number;
 }
-interface PartialTemplateConfig {
-    innerHTML: string;
-    startIndex: number;
-    endIndex: number;
-}
-type AccessCachedPathType = "access";
-export interface AccessCachedPath {
-    type: AccessCachedPathType;
-    relativePath: string;
-    absolutePath: string;
-}
-type DefaultCachedPathType = "default";
-export interface DefaultCachedPath {
-    type: DefaultCachedPathType;
-    paths: Record<string, CachedPath>;
-}
-type EventCachedPathType = "event";
-export interface EventCachedPath {
-    type: EventCachedPathType;
-    relativePath: string;
-    absolutePath: string;
-}
-type RepeatCachedPathType = "repeat";
-export interface RepeatCachedPath {
-    type: RepeatCachedPathType;
-    context: string;
-    paths: Record<string, CachedPath>;
-}
-export type CachedPath = DefaultCachedPath | RepeatCachedPath | AccessCachedPath | EventCachedPath;
-export type CachedPathMap = Record<string, CachedPath>;
-export 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;
-}
 /**
  * Get the index of the next matching tag
  * @param openingTagStartSlice - The slice starting from the opening tag
@@ -95,18 +51,6 @@ export declare function getIndexOfNextMatchingTag(openingTagStartSlice: string,
  * @returns DataBindingBehaviorConfig | DirectiveBehaviorConfig | null - A configuration object or null
  */
 export declare function getNextBehavior(innerHTML: string): DataBindingBehaviorConfig | TemplateDirectiveBehaviorConfig | null;
-/**
- * Gets all the partials with their IDs
- * @param innerHTML - The innerHTML string to evaluate
- * @param offset - The index offset from the innerHTML
- * @param partials - The partials found
- * @returns {[key: string]: PartialTemplateConfig}
- */
-export declare function getAllPartials(innerHTML: string, offset?: number, partials?: {
-    [key: string]: PartialTemplateConfig;
-}): {
-    [key: string]: PartialTemplateConfig;
-};
 /**
  * Create a function to resolve a value from an object using a path with dot syntax.
  * e.g. "foo.bar"
@@ -114,9 +58,9 @@ export declare function getAllPartials(innerHTML: string, offset?: number, parti
  * @param self - Where the first item in the path path refers to the item itself (used by repeat).
  * @returns A function to access the value from a given path.
  */
-export declare function pathResolver(path: string, self?: boolean): (accessibleObject: any, context: any) => any;
-export declare function bindingResolver(path: string, self: boolean | undefined, parentContext: string | null, type: PathType, observerMap: ObserverMap | null, contextPath: string | null, level: number): (accessibleObject: any, context: any) => any;
-export declare function expressionResolver(self: boolean, expression: ChainedExpression, parentContext: string | null, level: number, observerMap?: ObserverMap): (accessibleObject: any, context: any) => any;
+export declare function pathResolver(path: string, contextPath: string | null, level: number, rootSchema: JSONSchema): (accessibleObject: any, context: any) => any;
+export declare function bindingResolver(rootPropertyName: string | null, path: string, parentContext: string | null, type: PathType, schema: Schema, currentContext: string | null, level: number): (accessibleObject: any, context: any) => any;
+export declare function expressionResolver(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (accessibleObject: any, context: any) => any;
 /**
  * Extracts all paths from a ChainedExpression, including nested expressions
  * @param chainedExpression - The chained expression to extract paths from
@@ -169,16 +113,36 @@ export declare function transformInnerHTML(innerHTML: string, index?: number): s
  * @param self - Where the first item in the path path refers to the item itself (used by repeat).
  * @param chainedExpression - The chained expression which includes the expression and the next expression
  * if there is another in the chain
- * @param observerMap - Optional ObserverMap instance for caching paths during template processing
  * @returns - A binding that resolves the chained expression logic
  */
-export declare function resolveWhen(self: boolean, expression: ChainedExpression, parentContext: string | null, level: number, observerMap?: ObserverMap): (x: boolean, c: any) => any;
+export declare function resolveWhen(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (x: boolean, c: any) => any;
+/**
+ * Assign observables to data
+ * @param schema - The schema
+ * @param rootSchema - The root schema mapping to the root property
+ * @param data - The data
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @returns
+ */
+export declare function assignObservables(schema: JSONSchema | JSONSchemaDefinition, rootSchema: JSONSchema, data: any, target: any, rootProperty: string): typeof Proxy;
+/**
+ * Assign a proxy to an object
+ * @param schema - The current schema
+ * @param rootSchema - The root schema for the root property
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @param object - The object to assign the proxy to
+ * @returns Proxy object
+ */
+export declare function assignProxy(schema: JSONSchema | JSONSchemaDefinition, rootSchema: JSONSchema, target: any, rootProperty: string, object: any): typeof Proxy;
 /**
- * Get the next property
- * @param path The dot syntax data path
- * @returns The next property
+ * Get the root property name
+ * @param rootPropertyName - The root property
+ * @param path - The dot syntax path
+ * @param context - The context created by a repeat
+ * @param type - The type of path binding
+ * @returns
  */
-export declare function getNextProperty(path: string): string;
-export declare function assignObservables(cachePath: CachedPath, data: any, target: any, rootProperty: string): typeof Proxy;
-export declare function assignProxy(cachePath: CachedPath, target: any, rootProperty: string, object: any): typeof Proxy;
+export declare function getRootPropertyName(rootPropertyName: string | null, path: string, context: null | string, type: PathType): string | null;
 export {};