babylonjs-accessibility 7.16.0 → 7.16.1

package/babylon.accessibility.module.d.ts

@@ -1,35 +1,81 @@
 
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinAccessibilityItem" {
-import { ReactElement } from "react";
-import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
-export interface IHTMLTwinItemComponentProps {
-    description: string | undefined;
-    children: ReactElement[];
-    a11yItem: HTMLTwinItem;
+declare module "babylonjs-accessibility/index" {
+export * from "babylonjs-accessibility/HtmlTwin/index";
+
 }
+declare module "babylonjs-accessibility/legacy/legacy" {
+export * from "babylonjs-accessibility/index";
 
+}
+declare module "babylonjs-accessibility/HtmlTwin/index" {
+export * from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
 
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinGUIItem" {
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinSceneTree" {
 import { Scene } from "babylonjs/scene";
-import { Control } from "babylonjs-gui/2D/controls/control";
-import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
 import { IHTMLTwinRendererOptions } from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
 /**
- * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
+ * The scene tree of the HTML twin. It contain all the top level nodes
+ * @param props
+ * @returns
  */
-export class HTMLTwinGUIItem extends HTMLTwinItem {
+export function HTMLTwinSceneTree(props: {
+    scene: Scene;
+    options: IHTMLTwinRendererOptions;
+
+
+}
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinSceneContext" {
+/// <reference types="react" />
+/**
+ * Context used to update a scene when an entity is added or removed from the accessibility tree.
+ */
+export interface ISceneContext {
+    updateScene: () => void;
+}
+export const SceneContext: import("react").Context<ISceneContext>;
+
+}
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer" {
+import { Scene } from "babylonjs/scene";
+/**
+ * Options for the HTMLTwinRenderer.
+ */
+export interface IHTMLTwinRendererOptions {
     /**
-     * The corresponding BabylonJS entity. Can be a Node or a Control.
+     * If this is true, all GUI controls will be added to the twin tree, regardless if they have
+     * a defined accessibility tag or not. If it's false, only controls with an accessibility tag
+     * will be added. True by default.
      */
-    entity: Control;
-    constructor(entity: Control, scene: Scene);
+    addAllControls: boolean;
+}
+/**
+ * This class is the main entry point for the HTML twin renderer. To render a twin for a scene,
+ * simply call HTMLTwinRenderer.Render(scene).
+ */
+export class HTMLTwinRenderer {
     /**
-     * The text content displayed in HTML element.
-     * @param options - Options to render HTML twin tree where this element is contained.
-     * @returns The text content displayed in HTML element.
+     * Render the HTML twin for the given scene.
+     * @param scene the scene to render the twin for
+     * @param options options for the renderer
      */
-    getDescription(options: IHTMLTwinRendererOptions): string;
+    static Render(scene: Scene, options?: IHTMLTwinRendererOptions): void;
+}
+
+}
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinNodeItem" {
+import { Node } from "babylonjs/node";
+import { Scene } from "babylonjs/scene";
+import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
+/**
+ * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
+ */
+export class HTMLTwinNodeItem extends HTMLTwinItem {
+    /**
+     * The corresponding BabylonJS entity. Can be a Node or a Control.
+     */
+    entity: Node;
+    constructor(entity: Node, scene: Scene);
     /**
      * If this entity is actionable (can be clicked).
      */
@@ -52,27 +98,25 @@ export class HTMLTwinGUIItem extends HTMLTwinItem {
      * @param eventType - Which event is triggered. E.g. "click", "contextmenu"
      */
     triggerEvent(eventType: string): void;
+    private _getTriggerActions;
 }
 
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinHostComponent" {
-import * as React from "react";
-import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinItemAdapter" {
+import { AccessibilityEntity } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
 import { Scene } from "babylonjs/scene";
 import { IHTMLTwinRendererOptions } from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
-interface IHTMLTwinHostComponentProps {
+/**
+ * An adapter that transforms a Accessible entity in a React element. Contains observables for the events that can
+ * change the state of the entity or the accesible tree.
+ * @param props the props of the adapter
+ * @returns
+ */
+export function HTMLTwinItemAdapter(props: {
+    node: AccessibilityEntity;
     scene: Scene;
-    options?: IHTMLTwinRendererOptions;
-}
-interface IHTMLTwinHostComponentState {
-    a11yTreeItems: HTMLTwinItem[];
-}
-export class HTMLTwinHostComponent extends React.Component<IHTMLTwinHostComponentProps, IHTMLTwinHostComponentState> {
-    private _options;
-    constructor(props: IHTMLTwinHostComponentProps);
+    options: IHTMLTwinRendererOptions;
 
-}
-export {};
 
 }
 declare module "babylonjs-accessibility/HtmlTwin/htmlTwinItem" {
@@ -159,36 +203,46 @@ export class HTMLTwinItem {
 }
 
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinItemAdapter" {
-import { AccessibilityEntity } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinHostComponent" {
+import * as React from "react";
+import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
 import { Scene } from "babylonjs/scene";
 import { IHTMLTwinRendererOptions } from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
-/**
- * An adapter that transforms a Accessible entity in a React element. Contains observables for the events that can
- * change the state of the entity or the accesible tree.
- * @param props the props of the adapter
- * @returns
- */
-export function HTMLTwinItemAdapter(props: {
-    node: AccessibilityEntity;
+interface IHTMLTwinHostComponentProps {
     scene: Scene;
-    options: IHTMLTwinRendererOptions;
+    options?: IHTMLTwinRendererOptions;
+}
+interface IHTMLTwinHostComponentState {
+    a11yTreeItems: HTMLTwinItem[];
+}
+export class HTMLTwinHostComponent extends React.Component<IHTMLTwinHostComponentProps, IHTMLTwinHostComponentState> {
+    private _options;
+    constructor(props: IHTMLTwinHostComponentProps);
 
+}
+export {};
 
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinNodeItem" {
-import { Node } from "babylonjs/node";
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinGUIItem" {
 import { Scene } from "babylonjs/scene";
+import { Control } from "babylonjs-gui/2D/controls/control";
 import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
+import { IHTMLTwinRendererOptions } from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
 /**
  * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
  */
-export class HTMLTwinNodeItem extends HTMLTwinItem {
+export class HTMLTwinGUIItem extends HTMLTwinItem {
     /**
      * The corresponding BabylonJS entity. Can be a Node or a Control.
      */
-    entity: Node;
-    constructor(entity: Node, scene: Scene);
+    entity: Control;
+    constructor(entity: Control, scene: Scene);
+    /**
+     * The text content displayed in HTML element.
+     * @param options - Options to render HTML twin tree where this element is contained.
+     * @returns The text content displayed in HTML element.
+     */
+    getDescription(options: IHTMLTwinRendererOptions): string;
     /**
      * If this entity is actionable (can be clicked).
      */
@@ -211,104 +265,86 @@ export class HTMLTwinNodeItem extends HTMLTwinItem {
      * @param eventType - Which event is triggered. E.g. "click", "contextmenu"
      */
     triggerEvent(eventType: string): void;
-    private _getTriggerActions;
 }
 
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer" {
-import { Scene } from "babylonjs/scene";
-/**
- * Options for the HTMLTwinRenderer.
- */
-export interface IHTMLTwinRendererOptions {
-    /**
-     * If this is true, all GUI controls will be added to the twin tree, regardless if they have
-     * a defined accessibility tag or not. If it's false, only controls with an accessibility tag
-     * will be added. True by default.
-     */
-    addAllControls: boolean;
-}
-/**
- * This class is the main entry point for the HTML twin renderer. To render a twin for a scene,
- * simply call HTMLTwinRenderer.Render(scene).
- */
-export class HTMLTwinRenderer {
-    /**
-     * Render the HTML twin for the given scene.
-     * @param scene the scene to render the twin for
-     * @param options options for the renderer
-     */
-    static Render(scene: Scene, options?: IHTMLTwinRendererOptions): void;
+declare module "babylonjs-accessibility/HtmlTwin/htmlTwinAccessibilityItem" {
+import { ReactElement } from "react";
+import { HTMLTwinItem } from "babylonjs-accessibility/HtmlTwin/htmlTwinItem";
+export interface IHTMLTwinItemComponentProps {
+    description: string | undefined;
+    children: ReactElement[];
+    a11yItem: HTMLTwinItem;
 }
 
+
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinSceneContext" {
-/// <reference types="react" />
-/**
- * Context used to update a scene when an entity is added or removed from the accessibility tree.
- */
-export interface ISceneContext {
-    updateScene: () => void;
-}
-export const SceneContext: import("react").Context<ISceneContext>;
 
+declare module "babylonjs-accessibility" {
+    export * from "babylonjs-accessibility/legacy/legacy";
 }
-declare module "babylonjs-accessibility/HtmlTwin/htmlTwinSceneTree" {
-import { Scene } from "babylonjs/scene";
-import { IHTMLTwinRendererOptions } from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
-/**
- * The scene tree of the HTML twin. It contain all the top level nodes
- * @param props
- * @returns
- */
-export function HTMLTwinSceneTree(props: {
-    scene: Scene;
-    options: IHTMLTwinRendererOptions;
 
 
-}
-declare module "babylonjs-accessibility/HtmlTwin/index" {
-export * from "babylonjs-accessibility/HtmlTwin/htmlTwinRenderer";
+declare module BABYLON.Accessibility {
 
-}
-declare module "babylonjs-accessibility/index" {
-export * from "babylonjs-accessibility/HtmlTwin/index";
 
-}
-declare module "babylonjs-accessibility/legacy/legacy" {
-export * from "babylonjs-accessibility/index";
 
-}
 
-declare module "babylonjs-accessibility" {
-    export * from "babylonjs-accessibility/legacy/legacy";
-}
+    /**
+     * The scene tree of the HTML twin. It contain all the top level nodes
+     * @param props
+     * @returns
+     */
+    export function HTMLTwinSceneTree(props: {
+        scene: BABYLON.Scene;
+        options: IHTMLTwinRendererOptions;
+    }): import("react/jsx-runtime").JSX.Element;
 
 
-declare module BABYLON.Accessibility {
-    export interface IHTMLTwinItemComponentProps {
-        description: string | undefined;
-        children: React.ReactElement[];
-        a11yItem: HTMLTwinItem;
+    /// <reference types="react" />
+    /**
+     * Context used to update a scene when an entity is added or removed from the accessibility tree.
+     */
+    export interface ISceneContext {
+        updateScene: () => void;
     }
-    export function HTMLTwinAccessibilityItem(props: IHTMLTwinItemComponentProps): import("react/jsx-runtime").JSX.Element;
+    export var SceneContext: import("react").Context<ISceneContext>;
 
 
     /**
-     * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
+     * Options for the HTMLTwinRenderer.
      */
-    export class HTMLTwinGUIItem extends HTMLTwinItem {
+    export interface IHTMLTwinRendererOptions {
         /**
-         * The corresponding BabylonJS entity. Can be a Node or a BABYLON.GUI.Control.
+         * If this is true, all GUI controls will be added to the twin tree, regardless if they have
+         * a defined accessibility tag or not. If it's false, only controls with an accessibility tag
+         * will be added. True by default.
          */
-        entity: BABYLON.GUI.Control;
-        constructor(entity: BABYLON.GUI.Control, scene: BABYLON.Scene);
+        addAllControls: boolean;
+    }
+    /**
+     * This class is the main entry point for the HTML twin renderer. To render a twin for a scene,
+     * simply call HTMLTwinRenderer.Render(scene).
+     */
+    export class HTMLTwinRenderer {
         /**
-         * The text content displayed in HTML element.
-         * @param options - Options to render HTML twin tree where this element is contained.
-         * @returns The text content displayed in HTML element.
+         * Render the HTML twin for the given scene.
+         * @param scene the scene to render the twin for
+         * @param options options for the renderer
          */
-        getDescription(options: IHTMLTwinRendererOptions): string;
+        static Render(scene: BABYLON.Scene, options?: IHTMLTwinRendererOptions): void;
+    }
+
+
+    /**
+     * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
+     */
+    export class HTMLTwinNodeItem extends HTMLTwinItem {
+        /**
+         * The corresponding BabylonJS entity. Can be a BABYLON.Node or a Control.
+         */
+        entity: BABYLON.Node;
+        constructor(entity: BABYLON.Node, scene: BABYLON.Scene);
         /**
          * If this entity is actionable (can be clicked).
          */
@@ -331,21 +367,21 @@ declare module BABYLON.Accessibility {
          * @param eventType - Which event is triggered. E.g. "click", "contextmenu"
          */
         triggerEvent(eventType: string): void;
+        private _getTriggerActions;
     }
 
 
-    interface IHTMLTwinHostComponentProps {
+    /**
+     * An adapter that transforms a Accessible entity in a React element. Contains observables for the events that can
+     * change the state of the entity or the accesible tree.
+     * @param props the props of the adapter
+     * @returns
+     */
+    export function HTMLTwinItemAdapter(props: {
+        node: AccessibilityEntity;
         scene: BABYLON.Scene;
-        options?: IHTMLTwinRendererOptions;
-    }
-    interface IHTMLTwinHostComponentState {
-        a11yTreeItems: HTMLTwinItem[];
-    }
-    export class HTMLTwinHostComponent extends React.Component<IHTMLTwinHostComponentProps, IHTMLTwinHostComponentState> {
-        private _options;
-        constructor(props: IHTMLTwinHostComponentProps);
-        render(): import("react/jsx-runtime").JSX.Element;
-    }
+        options: IHTMLTwinRendererOptions;
+    }): import("react/jsx-runtime").JSX.Element | null;
 
 
     /**
@@ -426,28 +462,35 @@ declare module BABYLON.Accessibility {
     }
 
 
-    /**
-     * An adapter that transforms a Accessible entity in a React element. Contains observables for the events that can
-     * change the state of the entity or the accesible tree.
-     * @param props the props of the adapter
-     * @returns
-     */
-    export function HTMLTwinItemAdapter(props: {
-        node: AccessibilityEntity;
+    interface IHTMLTwinHostComponentProps {
         scene: BABYLON.Scene;
-        options: IHTMLTwinRendererOptions;
-    }): import("react/jsx-runtime").JSX.Element | null;
+        options?: IHTMLTwinRendererOptions;
+    }
+    interface IHTMLTwinHostComponentState {
+        a11yTreeItems: HTMLTwinItem[];
+    }
+    export class HTMLTwinHostComponent extends React.Component<IHTMLTwinHostComponentProps, IHTMLTwinHostComponentState> {
+        private _options;
+        constructor(props: IHTMLTwinHostComponentProps);
+        render(): import("react/jsx-runtime").JSX.Element;
+    }
 
 
     /**
      * A abstract layer to store the html twin tree structure. It is constructed from the BabylonJS scene entities that need to be accessible. It informs the parent-children relationship of html twin tree, and informs how to render: description, isActionable, onclick/onrightclick/onfocus/onblur.
      */
-    export class HTMLTwinNodeItem extends HTMLTwinItem {
+    export class HTMLTwinGUIItem extends HTMLTwinItem {
         /**
-         * The corresponding BabylonJS entity. Can be a BABYLON.Node or a Control.
+         * The corresponding BabylonJS entity. Can be a Node or a BABYLON.GUI.Control.
          */
-        entity: BABYLON.Node;
-        constructor(entity: BABYLON.Node, scene: BABYLON.Scene);
+        entity: BABYLON.GUI.Control;
+        constructor(entity: BABYLON.GUI.Control, scene: BABYLON.Scene);
+        /**
+         * The text content displayed in HTML element.
+         * @param options - Options to render HTML twin tree where this element is contained.
+         * @returns The text content displayed in HTML element.
+         */
+        getDescription(options: IHTMLTwinRendererOptions): string;
         /**
          * If this entity is actionable (can be clicked).
          */
@@ -470,58 +513,15 @@ declare module BABYLON.Accessibility {
          * @param eventType - Which event is triggered. E.g. "click", "contextmenu"
          */
         triggerEvent(eventType: string): void;
-        private _getTriggerActions;
     }
 
 
-    /**
-     * Options for the HTMLTwinRenderer.
-     */
-    export interface IHTMLTwinRendererOptions {
-        /**
-         * If this is true, all GUI controls will be added to the twin tree, regardless if they have
-         * a defined accessibility tag or not. If it's false, only controls with an accessibility tag
-         * will be added. True by default.
-         */
-        addAllControls: boolean;
-    }
-    /**
-     * This class is the main entry point for the HTML twin renderer. To render a twin for a scene,
-     * simply call HTMLTwinRenderer.Render(scene).
-     */
-    export class HTMLTwinRenderer {
-        /**
-         * Render the HTML twin for the given scene.
-         * @param scene the scene to render the twin for
-         * @param options options for the renderer
-         */
-        static Render(scene: BABYLON.Scene, options?: IHTMLTwinRendererOptions): void;
-    }
-
-
-    /// <reference types="react" />
-    /**
-     * Context used to update a scene when an entity is added or removed from the accessibility tree.
-     */
-    export interface ISceneContext {
-        updateScene: () => void;
+    export interface IHTMLTwinItemComponentProps {
+        description: string | undefined;
+        children: React.ReactElement[];
+        a11yItem: HTMLTwinItem;
     }
-    export var SceneContext: import("react").Context<ISceneContext>;
-
-
-    /**
-     * The scene tree of the HTML twin. It contain all the top level nodes
-     * @param props
-     * @returns
-     */
-    export function HTMLTwinSceneTree(props: {
-        scene: BABYLON.Scene;
-        options: IHTMLTwinRendererOptions;
-    }): import("react/jsx-runtime").JSX.Element;
-
-
-
-
+    export function HTMLTwinAccessibilityItem(props: IHTMLTwinItemComponentProps): import("react/jsx-runtime").JSX.Element;
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-accessibility",
-    "version": "7.16.0",
+    "version": "7.16.1",
     "main": "babylon.accessibility.max.js",
     "types": "babylon.accessibility.module.d.ts",
     "files": [
@@ -14,8 +14,8 @@
         "clean": "rimraf dist && rimraf babylon*.*"
     },
     "dependencies": {
-        "babylonjs": "^7.16.0",
-        "babylonjs-gui": "^7.16.0"
+        "babylonjs": "^7.16.1",
+        "babylonjs-gui": "^7.16.1"
     },
     "devDependencies": {
         "@dev/build-tools": "1.0.0",