web-component-wrapper 0.0.391 → 0.0.392

package/React.d.ts

@@ -1,8 +1,8 @@
 import { Mapping } from 'clientnode/type';
-import React, { HTMLAttributes } from 'react';
+import React from 'react';
 import { Root as ReactRoot } from 'react-dom/client';
 import Web from './Web';
-import { ComponentAdapter, ComponentType, ReactRenderItemFactory, ReactRenderItemsFactory, ReactRenderItems, WebComponentAPI } from './type';
+import { ComponentType, ReactComponentBaseProperties, ReactRenderItemFactory, ReactRenderItemsFactory, ReactRenderItems, WebComponentAPI } from './type';
 /**
  * Adapter for exposing a react component as web-component.
  * @property static:attachWebComponentAdapterIfNotExists - Indicates whether to
@@ -19,14 +19,7 @@ import { ComponentAdapter, ComponentType, ReactRenderItemFactory, ReactRenderIte
  * reacts memorizing wrapper to cache component render results.
  * @property isWrapped - Indicates whether react component is wrapped already.
  */
-export declare class ReactWeb<TElement = HTMLElement, ExternalProperties extends Mapping<unknown> = Mapping<unknown>, InternalProperties extends Mapping<unknown> & {
-    children?: Array<React.ReactNode> | React.ReactNode;
-    dangerouslySetInnerHTML?: HTMLAttributes<TElement>['dangerouslySetInnerHTML'];
-    key?: string;
-    ref?: null | {
-        current?: ComponentAdapter;
-    };
-} = Mapping<unknown>> extends Web<TElement, ExternalProperties, InternalProperties> {
+export declare class ReactWeb<TElement = HTMLElement, ExternalProperties extends Mapping<unknown> = Mapping<unknown>, InternalProperties extends ReactComponentBaseProperties<TElement> = Mapping<unknown>> extends Web<TElement, ExternalProperties, InternalProperties> {
     static attachWebComponentAdapterIfNotExists: boolean;
     static content: ComponentType | string;
     static react: typeof React;
@@ -193,5 +186,5 @@ export declare class ReactWeb<TElement = HTMLElement, ExternalProperties extends
      */
     static removeKnownUnwantedPropertyKeys(target: typeof ReactWeb, properties: Mapping<unknown>): void;
 }
-export declare const api: WebComponentAPI<typeof ReactWeb>;
+export declare const api: WebComponentAPI<HTMLElement, Mapping<unknown>, ReactComponentBaseProperties, typeof ReactWeb>;
 export default ReactWeb;

package/Web.d.ts

@@ -474,5 +474,5 @@ export declare class Web<TElement = HTMLElement, ExternalProperties extends Mapp
      */
     render(reason?: string): void;
 }
-export declare const api: WebComponentAPI<typeof Web>;
+export declare const api: WebComponentAPI<HTMLElement, Mapping<unknown>, Mapping<unknown>, typeof Web>;
 export default Web;

package/index.d.ts

@@ -1,10 +1,11 @@
+/// <reference types="react" />
 import { Mapping } from 'clientnode/type';
 import ReactWebImport from './React';
 import WebImport from './Web';
-import { ComponentType, WebComponentAPI, WebComponentConfiguration } from './type';
+import { AttributesReflectionConfiguration, ComponentType, EventToPropertyMapping, PropertiesConfiguration, WebComponentAPI, WebComponentConfiguration } from './type';
 export declare const ReactWeb: typeof ReactWebImport;
-export declare const reactWebAPI: WebComponentAPI<typeof ReactWebImport>;
-export declare const webAPI: WebComponentAPI<typeof WebImport>;
+export declare const reactWebAPI: WebComponentAPI<HTMLElement, Mapping<unknown>, import("./type").ReactComponentBaseProperties<HTMLElement>, typeof ReactWebImport>;
+export declare const webAPI: WebComponentAPI<HTMLElement, Mapping<unknown>, Mapping<unknown>, typeof WebImport>;
 export declare const Web: typeof WebImport;
 /**
  * Wraps given react component as web component.
@@ -15,5 +16,37 @@ export declare const Web: typeof WebImport;
  *
  * @returns Generated object to register and retrieve generated web component.
  */
-export declare const wrapAsWebComponent: <Type extends ComponentType<Mapping<unknown>> = ComponentType<Mapping<unknown>>, ExternalProperties extends Mapping<unknown> = Mapping<unknown>, InternalProperties extends Mapping<unknown> = Mapping<unknown>, EventParameters extends unknown[] = unknown[]>(component: Type, nameHint?: string, configuration?: WebComponentConfiguration<ExternalProperties, InternalProperties, EventParameters>) => WebComponentAPI<typeof ReactWeb>;
+export declare const wrapAsWebComponent: <Type extends ComponentType<Mapping<unknown>> = ComponentType<Mapping<unknown>>, ExternalProperties extends Mapping<unknown> = Mapping<unknown>, InternalProperties extends Mapping<unknown> = Mapping<unknown>, EventParameters extends unknown[] = unknown[]>(component: Type, nameHint?: string, configuration?: WebComponentConfiguration<ExternalProperties, InternalProperties, EventParameters>) => WebComponentAPI<Type, ExternalProperties, InternalProperties, {
+    new (): ReactWebImport<Type, ExternalProperties, InternalProperties>;
+    attachWebComponentAdapterIfNotExists: boolean;
+    content: string | ComponentType<Mapping<unknown>>;
+    react: typeof import("react");
+    _name: string;
+    isReactComponent(domNode: Node): boolean;
+    removeKnownUnwantedPropertyKeys(target: typeof ReactWebImport, properties: Mapping<unknown>): void;
+    applyRootBinding: boolean;
+    determineRootBinding: boolean;
+    shadowDOM: boolean | {
+        delegateFocus?: boolean | undefined;
+        mode: "closed" | "open";
+    } | null;
+    observedAttributes: string[];
+    controllableProperties: string[];
+    eventToPropertyMapping: EventToPropertyMapping<Mapping<unknown>, Mapping<unknown>, unknown[]> | null;
+    propertyAliases: Mapping<string>;
+    propertyTypes: PropertiesConfiguration;
+    propertiesToReflectAsAttributes: AttributesReflectionConfiguration;
+    renderProperties: string[];
+    cloneSlots: boolean;
+    evaluateSlots: boolean;
+    renderSlots: boolean;
+    trimSlots: boolean;
+    renderUnsafe: boolean;
+    _propertyAliasIndex: Mapping<string> | undefined;
+    _propertiesToReflectAsAttributes: import("./type").NormalizedAttributesReflectionConfiguration;
+    replaceDomNodes(domNode: HTMLElement, children: Node | Node[]): void;
+    unwrapDomNode(domNode: HTMLElement): ChildNode[];
+    hasCode(content: unknown): boolean;
+    normalizePropertyTypeList(value: AttributesReflectionConfiguration): import("./type").NormalizedAttributesReflectionConfiguration;
+}>;
 export default wrapAsWebComponent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-component-wrapper",
-  "version": "0.0.391",
+  "version": "0.0.392",
   "description": "Generic web-component base class and framework specific wrapper.",
   "keywords": [
     "component",

package/type.d.ts

@@ -1,6 +1,6 @@
 import PropertyTypes, { ValidationMap } from 'clientnode/property-types';
 import { Mapping, TemplateFunction, ValueOf } from 'clientnode/type';
-import { ComponentType as ReactComponentType, ReactElement } from 'react';
+import React, { ComponentType as ReactComponentType, HTMLAttributes, ReactElement } from 'react';
 import Web from './Web';
 export declare type CompiledDomNodeTemplateItem = {
     children: Array<CompiledDomNodeTemplate>;
@@ -28,6 +28,14 @@ export declare type PreCompiledItem = {
     originalScopeNames: Array<string>;
     templateFunction: TemplateFunction;
 };
+export declare type ReactComponentBaseProperties<TElement = HTMLElement> = Mapping<unknown> & {
+    children?: Array<React.ReactNode> | React.ReactNode;
+    dangerouslySetInnerHTML?: HTMLAttributes<TElement>['dangerouslySetInnerHTML'];
+    key?: string;
+    ref?: null | {
+        current?: ComponentAdapter;
+    };
+};
 export declare type ReactRenderBaseItemFactory = (_scope: Mapping<unknown>) => ReactRenderBaseItem;
 export declare type ReactRenderItemFactory = (_scope: Mapping<unknown>) => ReactRenderItem;
 export declare type ReactRenderItemsFactory = Array<ReactRenderItemFactory> | ReactRenderItemFactory;
@@ -59,7 +67,7 @@ export interface ComponentAdapter<Properties = Mapping<unknown>, State = Mapping
     properties?: Properties;
     state?: State;
 }
-export declare type WebComponentAPI<WebComponent extends typeof Web = typeof Web> = {
-    component: WebComponent;
-    register: (_tagName?: string) => void;
+export declare type WebComponentAPI<TElement = HTMLElement, ExternalProperties extends Mapping<unknown> = Mapping<unknown>, InternalProperties extends Mapping<unknown> = Mapping<unknown>, Type extends typeof Web<TElement, ExternalProperties, InternalProperties> = typeof Web<TElement, ExternalProperties, InternalProperties>> = {
+    component: Type;
+    register: (tagName?: string) => void;
 };