native-document 1.0.28 → 1.0.30

package/types/plugins-manager.d.ts

@@ -0,0 +1,65 @@
+import {NDElement} from "./elements";
+import {ObservableItem} from "./observable";
+import { Map} from "./polyfill";
+
+type FrameworkEvents = {
+    // Observable Events
+    'CreateObservable': (observable: ObservableItem) => void;
+    'ObservableBeforeChange': (observable: ObservableItem) => void;
+    'ObservableAfterChange': (observable: ObservableItem) => void;
+    'ObservableSubscribe': (observable: ObservableItem, target?: any) => void;
+    'ObservableUnsubscribe': (observable: ObservableItem) => void;
+    'CreateObservableArray': (observer: ObservableItem) => void;
+    'CreateObservableComputed': (observable: ObservableItem, dependencies: ObservableItem[]) => void;
+
+    // Element Events
+    'NDElementCreated': (element: HTMLElement, ndElement: NDElement) => void;
+    'Setup': (element: HTMLElement, attributes?: any, customWrapper?: Function) => void;
+    'BeforeProcessChildren': (parent: HTMLElement | DocumentFragment) => void;
+    'AfterProcessChildren': (parent: HTMLElement | DocumentFragment) => void;
+    'BeforeProcessComponent': (component: Function) => void;
+};
+
+type EventMethodName = `on${Capitalize<keyof FrameworkEvents>}`;
+
+interface Plugin {
+    $name?: string;
+
+    init?(): void;
+    cleanup?(): void;
+
+    // NativeDocument Framework Events
+    onCreateObservable?: (observable: ObservableItem) => void;
+    onObservableBeforeChange?: (observable: ObservableItem) => void;
+    onObservableAfterChange?: (observable: ObservableItem) => void;
+    onObservableSubscribe?: (observable: ObservableItem, target?: any) => void;
+    onObservableUnsubscribe?: (observable: ObservableItem) => void;
+    onCreateObservableArray?: (observer: ObservableItem) => void;
+    onCreateObservableComputed?: (observable: ObservableItem, dependencies: ObservableItem[]) => void;
+    onNDElementCreated?: (element: HTMLElement, ndElement: NDElement) => void;
+    onSetup?: (element: HTMLElement, attributes?: any, customWrapper?: Function) => void;
+    onBeforeProcessChildren?: (parent: HTMLElement | DocumentFragment) => void;
+    onAfterProcessChildren?: (parent: HTMLElement | DocumentFragment) => void;
+    onBeforeProcessComponent?: (component: Function) => void;
+
+    // Other possible events
+    [key: string]: any;
+}
+
+interface IPluginsManager {
+    list(): Map<string, Plugin>;
+
+    add(name: string, plugin: Plugin): void;
+
+    remove(pluginName: string): void;
+
+    emit(event: string, ...data: any[]): void;
+}
+
+declare const PluginsManager: IPluginsManager;
+
+export type TypedPlugin<T extends Record<string, (...args: any[]) => void> = {}> = Plugin & {
+    [K in keyof T as K extends string ? `on${Capitalize<K>}` : never]: T[K];
+};
+
+export default PluginsManager;

package/types/polyfill.d.ts

@@ -5,4 +5,14 @@ export interface Set<T> {
     forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     readonly size: number;
+}
+
+export interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    readonly size: number;
 }

package/types/property-accumulator.d.ts

@@ -0,0 +1,33 @@
+import {ObservableItem} from "./observable";
+
+type CssPropertyValueType = string | ObservableItem | number;
+type ClassPropertyValueType = boolean | ObservableItem;
+
+interface cssPropertyAccumulator {
+    add(key: string, value: CssPropertyValueType): void;
+    value(): string | Record<string, CssPropertyValueType>;
+}
+
+interface classPropertyAccumulator {
+    add(key: string, value?: ClassPropertyValueType): void;
+    value(): string | Record<string, ClassPropertyValueType>;
+}
+
+
+type CssInitialValue = string | Record<string, CssPropertyValueType> | string[];
+type ClassInitialValue = string | Record<string, ClassPropertyValueType> | string[];
+
+export declare const cssPropertyAccumulator: (initialValue?: CssInitialValue) => cssPropertyAccumulator;
+
+
+export declare const classPropertyAccumulator: (initialValue?: ClassInitialValue) => classPropertyAccumulator;
+
+// Export des types pour usage externe
+export type {
+    cssPropertyAccumulator as CssPropertyAccumulatorType,
+    classPropertyAccumulator as ClassPropertyAccumulatorType,
+    CssPropertyValueType,
+    ClassPropertyValueType,
+    CssInitialValue,
+    ClassInitialValue
+};

package/types/validator.ts

@@ -0,0 +1,55 @@
+import {ObservableChecker, ObservableItem, ObservableProxy} from "./observable";
+import { NDElement, ValidChild } from "./elements";
+
+export type ValidChildren = ValidChild | ValidChild[];
+
+/**
+ * Validator utility class with type guards
+ */
+declare const Validator: {
+    isObservable(value: any): value is ObservableItem;
+
+    isProxy(value: any): value is ObservableProxy<any>;
+
+    isObservableChecker(value: any): value is ObservableChecker;
+
+    isArray(value: any): value is Array<any>;
+
+    isString(value: any): value is string;
+
+    isNumber(value: any): value is number;
+
+    isBoolean(value: any): value is boolean;
+
+    isFunction(value: any): value is Function;
+
+    isAsyncFunction(value: any): value is (...args: any[]) => Promise<any>;
+
+    isObject(value: any): value is object;
+
+    isJson(value: any): value is Record<string, any>;
+
+    isElement(value: any): value is HTMLElement | DocumentFragment | Text;
+
+    isFragment(value: any): value is DocumentFragment;
+
+    isStringOrObservable(value: any): value is string | ObservableItem<string>;
+
+    isValidChild(child: any): child is ValidChild;
+
+    isNDElement(child: any): child is NDElement;
+
+    isValidChildren(children: any): children is ValidChildren;
+
+    validateChildren(children: any): ValidChildren;
+
+    containsObservables(data: any): boolean;
+
+    containsObservableReference(data: any): data is string;
+
+    validateAttributes(attributes: any): Record<string, any> | null | undefined;
+
+    validateEventCallback(callback: any): asserts callback is Function;
+};
+
+export { Validator };