vivth 1.4.10 → 1.5.0

package/generated/types/src/neinth/VivthyNeinth.d.mts

@@ -0,0 +1,202 @@
+/**
+ * @typedef {import('../bundler/FileSelfMapper.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - alternative to `neinth`;
+ * @template {any} EXPORT
+ * @implements {VivthCleanup}
+ */
+export class VivthyNeinth<EXPORT extends unknown> implements VivthCleanup {
+    /**
+     * @type {QChannel<string>}
+     */
+    static #q: QChannel<string>;
+    static #hasStarted: boolean;
+    /**
+     * @type {Map<string, VivthyNeinth<any>>}
+     */
+    static #mappedInstance: Map<string, VivthyNeinth<any>>;
+    /**
+     * @type {Parameters<typeof VivthyNeinth["start"]>[0]["assemblyScriptOptions"]}
+     */
+    static #assemblyScriptOptions: Parameters<(typeof VivthyNeinth)["start"]>[0]["assemblyScriptOptions"];
+    /**
+     * @description
+     * - DO NOT CALL THIS METHOD INSIDE
+     * @param {Object} options
+     * @param {string} options.dirPath
+     * @param {import('../typehints/AutoDocASOptions.mjs').AutoDocASOptions} [options.assemblyScriptOptions]
+     * @returns {ReturnType<typeof TryAsync<void>>}
+     */
+    static start: ({ dirPath, assemblyScriptOptions }: {
+        dirPath: string;
+        assemblyScriptOptions?: import("../typehints/AutoDocASOptions.mjs").AutoDocASOptions | undefined;
+    }) => ReturnType<typeof TryAsync<void>>;
+    /**
+     * @param {import('chokidar/handler.js').EventName} eventName
+     * @param {string} path
+     * @param {import('node:fs').Stats} [stats]
+     */
+    static #watcherListenerQ: (eventName: import("chokidar/handler.js").EventName, path: string, stats?: import("node:fs").Stats) => Promise<void>;
+    /**
+     * @param {import('chokidar/handler.js').EventName} eventName
+     * @param {string} path
+     * @param {import('node:fs').Stats} [stats]
+     * @returns {void}
+     */
+    static #watcherListener: (eventName: import("chokidar/handler.js").EventName, path: string, stats?: import("node:fs").Stats) => void;
+    /**
+     * @param {'add'|'change'} _eventName
+     * @param {string} path
+     * @param {import('node:fs').Stats} [_stats]
+     * @returns {Promise<void>}
+     */
+    static #addListener: (_eventName: "add" | "change", path: string, _stats?: import("node:fs").Stats) => Promise<void>;
+    /**
+     * @param {string} _eventName
+     * @param {string} path
+     * @param {import('node:fs').Stats} [_stats]
+     * @returns {Promise<void>}
+     */
+    static #negativeListener: (_eventName: string, path: string, _stats?: import("node:fs").Stats) => Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    static #ifPrevInstanceExistThenCleanup_: (path: string) => Promise<void>;
+    /**
+     * @param {Object} options
+     * @param {(this:VivthyNeinth<EXPORT>, arg0:VivthyNeinth<EXPORT>)=>Promise<EXPORT>} options.export
+     * @param {boolean} [options.I__the_developer__have_provided_onFileMutations_cleanupCallbacks_for_every_long_running_object_in_this_file]
+     */
+    constructor({ export: exportCallback, I__the_developer__have_provided_onFileMutations_cleanupCallbacks_for_every_long_running_object_in_this_file, }: {
+        export: (this: VivthyNeinth<EXPORT>, arg0: VivthyNeinth<EXPORT>) => Promise<EXPORT>;
+        I__the_developer__have_provided_onFileMutations_cleanupCallbacks_for_every_long_running_object_in_this_file?: boolean | undefined;
+    });
+    /**
+     * @type { string }
+     */
+    path: string;
+    /**
+     * @description
+     * - use this to update export value;
+     * - `WARNING`: this instance setter are accesible from outside, including importer;
+     * >- usefull for treating `VivthyNeinth` instance as global signal;
+     * >- you can accidentally ;
+     * @param {EXPORT|undefined} newExportValue
+     * @returns {void}
+     * @example
+     */
+    set exportedValue(newExportValue: EXPORT | undefined);
+    /**
+     * @description
+     * - use this to listen to dependency changes(inside `Effect`);
+     * @returns {Promise<Derived<EXPORT|undefined>>}
+     * @example
+     */
+    get listener(): Promise<Derived<EXPORT | undefined>>;
+    /**
+     * @description
+     * - generate autoCleaned `Signal` instance;
+     * @example
+     * /// on VivthyNeinth callback scope
+     * const { newSignal } = this;
+     * const numberSignal = newSignal(1);
+     * ///
+     */
+    newSignal: <A extends unknown>(obj: A) => Signal<A>;
+    /**
+     * @description
+     * - generate autoCleaned `Effect` instance;
+     * @example
+     * /// on VivthyNeinth callback scope
+     * const { newEffect } = this;
+     * const numberSignal = newSignal(1);
+     * const effer = newEffect(async({subscribe})=>{
+     * 	const numberSignalValue = subscribe(numberSignal).value;
+     * });
+     * ///
+     */
+    newEffect: (callback: (arg0: Effect["options"]) => Promise<void>) => Effect;
+    /**
+     * @description
+     * - generate autoCleaned `Derived` instance;
+     * @example
+     * /// on VivthyNeinth callback scope
+     * const { newDerived } = this;
+     * const effer = newDerived(async({subscribe})=>{
+     * 	const numberSignalValue = subscribe(numberSignal).value;
+     * 	return numberSignalValue * 2;
+     * });
+     * ///
+     */
+    newDerived: <CB extends ConstructorParameters<typeof Derived>[0]>(callback: CB) => Derived<any>;
+    /**
+     * @description
+     * - manually registering object celeanup;
+     * @param {()=>Promise<void>} callback
+     * @returns {void}
+     * @example
+     * import { watch } from 'chokidar';
+     *
+     * /// on VivthyNeinth export callback scope
+     * const watcher = watch('D://my/dir/path');
+     * // preferably to declare the cleanup right bellow it's object creation;
+     * // set 'I__the_developer__have_provided_onFileMutations_cleanupCallbacks_for_every_long_running_object_in_this_file' to false if you might want to save before full cleanup is written;
+     * this.onMutate(async () => {
+     * 	watcher.removeAllListeners();
+     * 	watcher.close();
+     * });
+     *
+     * watcher.addListener('all', (eventName, path, stats) => {
+     * 	//
+     * })
+     * ///
+     * // alternative: use vivth `modules` that returns object that implements `VivthCleanup`;
+     * // and call uses `registerObjectWithAutoCleanup`;
+     */
+    onMutate: (callback: () => Promise<void>) => void;
+    /**
+     * @description
+     * - process SafeExit;
+     * @param {()=>Promise<void>} callback
+     * @returns {void}
+     * @example
+     * import { Console } from 'vivth/neutral';
+     *
+     * /// on VivthyNeinth export callback scope
+     * this.onExit(async()=>{
+     * 	Console.log('main process ends');
+     * })
+     * ///
+     */
+    onExit: (callback: () => Promise<void>) => void;
+    /**
+     * @description
+     * - register premade cleanup `vivthCleanup` method to `VivthyNeinth` lifecycle;
+     * @template {Object} OBJ
+     * @param { OBJ & VivthCleanup } obj
+     * @returns {OBJ}
+     * @example
+     * import { EsWatcher } from "vivth/node";
+     *
+     * /// on VivthyNeinth export callback scope
+     * const esWatcherInstance = this.registerObjectWithAutoCleanup(new EsWatcher({
+     * 	...buildOptions,
+     * }));
+     * ///
+     */
+    registerObjectWithAutoCleanup<OBJ extends Object>(obj: OBJ & VivthCleanup): OBJ;
+    /**
+     * @returns {Promise<void>}
+     */
+    vivthCleanup: () => Promise<void>;
+    #private;
+}
+export type VivthCleanup = import("../bundler/FileSelfMapper.mjs").VivthCleanup;
+import { Derived } from '../class/Derived.mjs';
+import { Signal } from '../class/Signal.mjs';
+import { Effect } from '../class/Effect.mjs';
+import { QChannel } from '../class/QChannel.mjs';
+import { TryAsync } from '../function/TryAsync.mjs';

package/generated/types/src/typehints/ArrayToKeys.d.mts

@@ -0,0 +1,23 @@
+/**
+ * @description
+ * - Internal utility to deduplicate a tuple
+ */
+export type Deduplicate<T extends readonly unknown[], ACC extends readonly unknown[] = []> = T extends readonly [infer Head, ...infer Tail] ? Head extends ACC[number] ? Deduplicate<Tail, ACC> : Deduplicate<Tail, readonly [...ACC, Head]> : ACC;
+/**
+ * @preserve
+ * @description
+ * - extract unique string from ArrayString[];
+ * - Takes an array/tuple type and returns a unique UNION of its elements.
+ * ```ts
+ * const a = ['hi', 'there'] as const;
+ * const check = (aa:ArrayToKeys<typeof a>) => {};
+ * ```
+ * ```js
+ * const a = /** [at]type {const} *[blank]/ (['hi', 'there']);
+ * /** [at]param {ArrayToKeys<typeof a>} aa *[blank]/
+ * const check = (aa) => {};
+ * ```
+ * @template {readonly unknown[]} T
+ * @[blank]typedef {import('./ArrayToKeys.mts').ArrayToKeys<T>} ArrayToKeys
+ */
+export type ArrayToKeys<T extends readonly unknown[]> = Deduplicate<T>[number];

package/generated/types/src/typehints/AssemblyScriptExportsType.d.mts

@@ -0,0 +1,4 @@
+/**
+ * - `AssemblyScript` `exports` type helper;
+ */
+export type AssemblyScriptExportsType<RESULTTYPE extends Record<string, unknown>> = Awaited<ReturnType<typeof import("@assemblyscript/loader").instantiate<RESULTTYPE>>>;

package/generated/types/src/typehints/AssemblyScriptLoaderInstantiate.d.mts

@@ -0,0 +1,4 @@
+/**
+ * - instantiate type helper;
+ */
+export type AssemblyScriptLoaderInstantiate<RESULTTYPE extends Record<string, unknown>> = typeof import("@assemblyscript/loader").instantiate<RESULTTYPE>;

package/generated/types/src/typehints/AutoDocASOptions.d.mts

@@ -0,0 +1,15 @@
+export type AutoDocASOptions = {
+    /**
+     * - `true`: will generate `${fileName}.mjs` that uses `FSasar`;
+     * >- upon compiling with `vivth` it should be embeded as inline buffer;
+     * - `false`: does nothing;
+     * - on both cases, the `${fileName}.js` can be used for both browser or nodeJS compatibel runtime;
+     */
+    generateFSasarImporter?: boolean | undefined;
+    /**
+     * - `argv` for assembley script compiler (`asc.main`), excluding `inputPath`, `--outputFile`, `--bindings`;
+     * >- `--bindings`: strictly using `esm`;
+     */
+    ASArgv?: string[] | undefined;
+    ASAPIOptions?: Parameters<typeof import("../bundler/CompileAS.mjs").CompileAS>[1];
+};

package/generated/types/src/typehints/ChainableType.d.mts

@@ -0,0 +1,3 @@
+export type ChainableType<OBJ extends object> = {
+    this: OBJ;
+} & { [K in keyof OBJ]: OBJ[K] extends (...args: any[]) => any ? (...args: Parameters<OBJ[K]>) => ChainableType<OBJ> : OBJ[K]; };

package/generated/types/src/typehints/ComponentDecorator_Constructor.d.mts

@@ -0,0 +1,3 @@
+export type ComponentDecorator_Constructor<BASE extends new (...args: any[]) => HTMLElement, ATTRS extends readonly string[]> = BASE & {
+    readonly observedAttributes: ATTRS;
+};

package/generated/types/src/typehints/ConsoleAdditionalSettingType.d.mts

@@ -0,0 +1,3 @@
+export type ConsoleAdditionalSettingType = {
+    now?: boolean | undefined;
+};

package/generated/types/src/typehints/Decorator.d.mts

@@ -0,0 +1,11 @@
+import type { ThisParameterOfOrUnknown } from './DecoratorMonkeyPatch.mts';
+/**
+ * @preserve
+ * @description
+ * - type helper to create decorator;
+ * >- matches argument with host method;
+ * @template {(...args: any[]) => any} OriginalFn - The original method type;
+ * @template {readonly unknown[]} DecoratorArgs - Tuple of custom decorator arguments;
+ * @[blank]typedef {import('./Decorator.mts').Decorator<OriginalFn, DecoratorArgs>} Decorator
+ */
+export type Decorator<OriginalFn extends (this: any, ...args: any[]) => any, DecoratorArgs extends readonly unknown[] = []> = DecoratorArgs['length'] extends 0 ? (target: OriginalFn, context: ClassMethodDecoratorContext<ThisParameterOfOrUnknown<OriginalFn>, OriginalFn>) => ((this: ThisParameterOfOrUnknown<OriginalFn>, ...args: Parameters<OriginalFn>) => any) | void : (...args: DecoratorArgs) => (target: OriginalFn, context: ClassMethodDecoratorContext<ThisParameterOfOrUnknown<OriginalFn>, OriginalFn>) => ((this: ThisParameterOfOrUnknown<OriginalFn>, ...args: Parameters<OriginalFn>) => any) | void;

package/generated/types/src/typehints/DecoratorMonkeyPatch.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Utility to extract the 'this' context from a function, defaulting to unknown.
+ */
+export type ThisParameterOfOrUnknown<T> = T extends (this: infer U, ...args: any[]) => any ? U : unknown;
+/**
+ * @preserve
+ * @description
+ * - type helper to create decorator for monkeypatching class/instance method;
+ * >- matches argument with host method;
+ * >- matches return type with host method;
+ * @template {(...args: any[]) => any} OriginalFn - The original method type;
+ * @template {readonly unknown[]} DecoratorArgs - Tuple of custom decorator arguments;
+ * @[blank]typedef {import('./DecoratorMonkeyPatch.mts').DecoratorMonkeyPatch<OriginalFn, DecoratorArgs>} DecoratorMonkeyPatch
+ */
+export type DecoratorMonkeyPatch<OriginalFn extends (this: any, ...args: any[]) => any, DecoratorArgs extends readonly unknown[] = []> = DecoratorArgs['length'] extends 0 ? (target: OriginalFn, context: ClassMethodDecoratorContext<ThisParameterOfOrUnknown<OriginalFn>, OriginalFn>) => ((this: ThisParameterOfOrUnknown<OriginalFn>, ...args: Parameters<OriginalFn>) => ReturnType<OriginalFn>) | void : (...args: DecoratorArgs) => (target: OriginalFn, context: ClassMethodDecoratorContext<ThisParameterOfOrUnknown<OriginalFn>, OriginalFn>) => ((this: ThisParameterOfOrUnknown<OriginalFn>, ...args: Parameters<OriginalFn>) => ReturnType<OriginalFn>) | void;

package/{types/src/types → generated/types/src/typehints}/DevTestCB.d.mts

@@ -1,3 +1,3 @@
-export type DevTestCB = (testName: string, testCallback: () => Promise<boolean>) => Promise<{
+export type DevTestCB = (testName: string, testCallback: () => Promise<boolean>) => {
     removeId: () => void;
-}>;
+};

package/generated/types/src/typehints/EnvModeType.d.mts

@@ -0,0 +1,4 @@
+/**
+ * - type helper for `EnvMode`;
+ */
+export type EnvModeType = "dev" | "prod";

package/generated/types/src/typehints/ListArg.d.mts

@@ -0,0 +1,4 @@
+/**
+ * - ListSignal argument type;
+ */
+export type ListArg = Record<string, any>;

package/generated/types/src/typehints/MonkeyPatchedType.d.mts

@@ -0,0 +1 @@
+export type MonkeyPatchedType<ORIOBJ extends unknown> = ORIOBJ extends (...args: infer A) => infer R ? (...args: A) => R : ORIOBJ extends abstract new (...args: infer C) => infer I ? abstract new (...args: C) => I : any;

package/generated/types/src/typehints/ParametersFollowingN.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Utility: build a tuple of length N filled with type T (default = any).
+ */
+export type TupleOfLength<N extends number, T = any, R extends any[] = []> = R['length'] extends N ? R : TupleOfLength<N, T, [...R, T]>;
+/**
+ * @preserve
+ * @description
+ * - Drop the first N parameters from METHOD and return the rest;
+ * @template {(...args: any[]) => any} METHOD
+ * @template {number} N
+ * @[blank]typedef {import('./ParametersFollowingN.mts').ParametersFollowingN<N, METHOD>} ParametersFollowingN
+ */
+export type ParametersFollowingN<METHOD extends (...args: any[]) => any, N extends number> = Parameters<METHOD> extends [...TupleOfLength<N>, ...infer Rest] ? Rest : [];

package/generated/types/src/typehints/PrefixedKeysOf.d.mts

@@ -0,0 +1 @@
+export type PrefixedKeysOf<T extends unknown, Prefix extends string> = Extract<keyof T, `${Prefix}${string}`>;

package/generated/types/src/typehints/Runtime.d.mts

@@ -0,0 +1,4 @@
+/**
+ * - for popular runtimes check;
+ */
+export type Runtime = "node" | "bun" | "browser" | "unknown";

package/generated/types/src/typehints/SafeImportReturnType.d.mts

@@ -0,0 +1 @@
+export type SafeImportReturnType<IMPORTTARGET extends unknown> = Awaited<ReturnType<typeof import("../function/SafeImport.mjs").SafeImport<IMPORTTARGET>>>;

package/generated/types/src/typehints/StylePropRefType.d.mts

@@ -0,0 +1,2 @@
+export type StylePropRefType<STRTYPE extends string> = ReturnType<typeof WC_StyleProp_bind>;
+import type { WC_StyleProp_bind } from '../web/bindings/WC_StyleProp_bind.mjs';

package/generated/types/src/typehints/TemplateLiteralValueHandler.d.mts

@@ -0,0 +1,10 @@
+/**
+ * - type helper for typing `vivth.TemplateLiteral`;
+ */
+export type TemplateLiteralValueHandler<INPUTTYPE extends unknown> = (arg0: {
+    currentValue: INPUTTYPE;
+    index: number;
+    templateStringsArray: TemplateStringsArray;
+    valuesArrays: INPUTTYPE[];
+    inputLength: number;
+}) => (string | Promise<string>);

package/generated/types/src/typehints/VLifecycleCallbacks.d.mts

@@ -0,0 +1,6 @@
+export type VLifecycleCallbacks<TAGNAME extends keyof HTMLElementTagNameMap> = {
+    onConnected?: ((this: HTMLElementTagNameMap[TAGNAME], defer: (onDisconnected: () => void) => void) => void) | undefined;
+    onDisconnected?: ((this: HTMLElementTagNameMap[TAGNAME]) => void) | undefined;
+    onAdopted?: ((this: HTMLElementTagNameMap[TAGNAME], defer: (onDisconnected: () => void) => void) => void) | undefined;
+    onAttributeChanged?: ((this: HTMLElementTagNameMap[TAGNAME], name: string, oldValue: string, newValue: string) => void) | undefined;
+};

package/generated/types/src/typehints/VivthCleanup.d.mts

@@ -0,0 +1,12 @@
+/**
+ * - you can call:
+ * ```js
+ * something.vivthCleanup();
+ * ```
+ * >- class that implements this;
+ * >- function that have this as part of it's return;
+ * - to clean up that object, usually a long lived process;
+ */
+export type VivthCleanup = {
+    vivthCleanup: () => Promise<any>;
+};

package/generated/types/src/web/BrowserDirMapper.d.mts

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - class helper to map dynamic mjs files;
+ * >- includes `mts` file too;
+ * @implements {VivthCleanup}
+ */
+export class BrowserDirMapper implements VivthCleanup {
+    /**
+     * @description
+     * - instantiate the mapper;
+     * @param {Object} path
+     * @param {string} path.watch
+     * @param {string} path.mapTo
+     * @param {(normalizedPath:string)=>boolean} [path.eachFilter]
+     * @param {ConstructorParameters<typeof JSDirMapper>[1] &
+     * 	{
+     * 		debounce?:number,
+     * 		chokidarOptions?:import('chokidar').ChokidarOptions
+     * 	}
+     * } options
+     * @example
+     * import { BrowserDirMapper } from 'vivth/node'
+     * import { Paths, SafeExit, BrowserDirMapper } from 'vivth/neutral';
+     *
+     * new Paths({
+     * 	root: process.env.INIT_CWD ?? process.cwd(),
+     * });
+     *
+     * new SafeExit();
+     *
+     * new BrowserDirMapper(
+     * 	{ mapTo: '/dist/', watch: '/src/' },
+     * 	{
+     * 		esbuild: {
+     * 			buildOptions: {
+     * 				minify: true,
+     * 			},
+     * 		},
+     * 	},
+     * );
+     */
+    constructor({ watch, mapTo, eachFilter }: {
+        watch: string;
+        mapTo: string;
+        eachFilter?: ((normalizedPath: string) => boolean) | undefined;
+    }, options: ConstructorParameters<typeof JSDirMapper>[1] & {
+        debounce?: number;
+        chokidarOptions?: import("chokidar").ChokidarOptions;
+    });
+    vivthCleanup: () => Promise<void>;
+    /**
+     * @description
+     * - `FSDirArchWatcher` instance;
+     * @type {FSDirArchWatcher<any>|undefined}
+     */
+    dynamicDirWatcher: FSDirArchWatcher<any> | undefined;
+    /**
+     * @description
+     * - `JSDirMapper` instance;
+     * @type {JSDirMapper<any>|undefined}
+     */
+    dirMapper: JSDirMapper<any> | undefined;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { FSDirArchWatcher } from '../class/FSDirArchWatcher.mjs';
+import { JSDirMapper } from '../bundler/JSDirMapper.mjs';

package/generated/types/src/web/EnsureValidTag.d.mts

@@ -0,0 +1,7 @@
+import type { WC_TagName_type } from './common/WC_TagName_type.mts';
+/**
+ * @preserve
+ * @template {string} T
+ * @[blank]typedef {import('./EnsureValidTag.mts').EnsureValidTag<T>} EnsureValidTag
+ */
+export type EnsureValidTag<T extends string> = WC_TagName_type<T> extends T ? T : 'INVALID_TAG_NAME';

package/generated/types/src/web/ViteAddDynamics.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @description
+ * - `vite.rollup/down` plugin abstraction for [NewDynamicsExport](#newdynamicsexport);
+ * @param {Parameters<typeof NewDynamicsExport>} args
+ * @returns {import('vite').PluginOption}
+ */
+export function ViteAddDynamics(args_0: {
+    rootPath: string;
+    debounce?: number | undefined;
+    useFetchForAssets?: boolean | undefined;
+    chokidarOptions?: Partial<{
+        persistent: boolean;
+        ignoreInitial: boolean;
+        followSymlinks: boolean;
+        cwd?: string;
+        usePolling: boolean;
+        interval: number;
+        binaryInterval: number;
+        alwaysStat?: boolean;
+        depth?: number;
+        ignorePermissionErrors: boolean;
+        atomic: boolean | number;
+    } & {
+        ignored: import("chokidar").Matcher | import("chokidar").Matcher[];
+        awaitWriteFinish: boolean | Partial<import("chokidar").AWF>;
+    }> | undefined;
+    eachFilter?: ((normalizedPath: string) => boolean) | undefined;
+}): import("vite").PluginOption;

package/generated/types/src/web/ViteGetAllHTMLFile.d.mts

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * - Automatically discovers HTML files in a directory and maps them to input keys;
+ * - [Paths](#paths) needs to be instantiated;
+ * @param {string} dirPath - The absolute or relative path to the directory to scan.
+ * @param {string} distPath - The distribution folder name to exclude.
+ * @returns {import('vite').PluginOption}
+ */
+export function ViteGetAllHTMLFile(dirPath: string, distPath: string): import("vite").PluginOption;

package/generated/types/src/web/WC_extendsA.d.mts

@@ -0,0 +1,135 @@
+/**
+ * @import {ArrayToKeys} from '../typehints/ArrayToKeys.mjs'
+ * @import {WC_TagName_type} from './common/WC_TagName_type.mjs'
+ */
+/**
+ * @typedef {typeof import('../function/IsTypeOf.mjs').TypeMap} TypeMap
+ */
+/**
+ * @description
+ * - Generates a base class for Web Component definitions.
+ * - Note: This generator does not support `connectedMoveCallback`.
+ * For the needs of opting in to [connectedMoveCallback](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements) functionality, use [WC_extendsB](#wc_extendsb) instead.
+ * - This class relies heavily on complex type inference which can cause issues, during declaration file generation. To avoid "circular type" errors or build failures, set the following in your `tsconfig.json`:
+ * ```json
+ * {
+ * 	"compilerOptions": {
+ * 		"declaration": false
+ * 	}
+ * }
+ * ```
+ * - By disabling `declaration`, you prevent the TypeScript compiler from attempting to resolve and export the complex recursive type definitions generated by this factory;
+ * @template {new (...args: any[]) => HTMLElement} BASE_CONSTRUCTOR
+ * @template {{
+ * 	class?:string;
+ * 	style?:string;
+ *  observedAttributes?: readonly string[];
+ *  namedSlots?: readonly string[];
+ * 	props?: Record<string, keyof TypeMap|(new (...args:any[])=>any)>;
+ * }} STANDARD
+ * @template {(BASE_CONSTRUCTOR) & {
+ * 	tagName: string;
+ * 	extendIs: string;
+ * 	observedAttributes?: STANDARD["observedAttributes"];
+ * 	namedSlots?: STANDARD["namedSlots"];
+ * 	props?: STANDARD["props"];
+ * }} CREATEARGS
+ * @template { (new (...args: any[]) => InstanceType<BASE_CONSTRUCTOR> & {
+ * 		setObservedAttributes(attributes:Partial<
+ * 			Record<ArrayToKeys<STANDARD["observedAttributes"]extends readonly string[]
+ * 				? STANDARD["observedAttributes"]
+ * 				:never>,
+ * 			string>
+ * 		>):void;
+ * 		props: NonNullable<NonNullable<Parameters<ReturnType<typeof WC_createElement_bind<CREATEARGS>>>[0]>["props"]>;
+ *    adoptedCallback():void;
+ *    connectedCallback():void;
+ *    disonnectedCallback():void;
+ * 		attributeChangedCallback(name:ArrayToKeys<STANDARD["observedAttributes"]extends readonly string[]?STANDARD["observedAttributes"]:never>, oldValue:string|null, newValue:string|null): void;
+ * 		ON:<OBJ extends Record<any, any> & {
+ * 				onConnected?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["connected"];
+ * 				onDisconnected?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["disconnected"];
+ * 				onAdopted?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["adopted"];
+ * 				onAttributeChanged?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["attributeChanged"];
+ * 			}>
+ * 		(obj:OBJ, callbacks?:
+ * 			{
+ * 				connected?:(obj:OBJ)=>void;
+ * 				disconnected?:(obj:OBJ)=>void;
+ * 				adopted?:(obj:OBJ)=>void;
+ * 				attributeChanged?:(
+ * 					obj:OBJ,
+ * 					name:STANDARD["observedAttributes"]extends readonly string[]
+ * 						? ArrayToKeys<STANDARD["observedAttributes"]>
+ * 						: never,
+ * 					oldValue:string|null,
+ * 					newValue:string|null
+ * 				)=>void;
+ * 			})=>OBJ;
+ *  }) & {
+ * 		tagName:string;
+ * 		extendIs:string;
+ *  	namedSlots: STANDARD["namedSlots"];
+ *  	observedAttributes: STANDARD["observedAttributes"];
+ * 		createNamedSlot: typeof WC_createNamedSlot<STANDARD>;
+ * 		props?: STANDARD["props"];
+ * 		define:<TAG extends string, CLASSREF extends CREATEARGS>
+ * 			(
+ * 				tagName:WC_TagName_type<TAG>,
+ * 				classRef:CLASSREF,
+ * 				elementDefinitionOptions?:ElementDefinitionOptions,
+ * 			)=>ReturnType<typeof WC_createElement_bind<CLASSREF>>;
+ * 	}
+ * } RET
+ * @param {BASE_CONSTRUCTOR} Base
+ * @param {STANDARD} [staticMember]
+ * @returns {RET}
+ * @example
+ * export MyWebComponent extends WC_extendsA(HTMLElement, {...options}){
+ * 	static create = this.define('my-webcomponent');
+ * }
+ */
+export function WC_extendsA<BASE_CONSTRUCTOR extends new (...args: any[]) => HTMLElement, STANDARD extends {
+    class?: string;
+    style?: string;
+    observedAttributes?: readonly string[];
+    namedSlots?: readonly string[];
+    props?: Record<string, keyof TypeMap | (new (...args: any[]) => any)>;
+}, CREATEARGS extends (BASE_CONSTRUCTOR) & {
+    tagName: string;
+    extendIs: string;
+    observedAttributes?: STANDARD["observedAttributes"];
+    namedSlots?: STANDARD["namedSlots"];
+    props?: STANDARD["props"];
+}, RET extends (new (...args: any[]) => InstanceType<BASE_CONSTRUCTOR> & {
+    setObservedAttributes(attributes: Partial<Record<ArrayToKeys<STANDARD["observedAttributes"] extends readonly string[] ? STANDARD["observedAttributes"] : never>, string>>): void;
+    props: NonNullable<NonNullable<Parameters<ReturnType<typeof WC_createElement_bind<CREATEARGS>>>[0]>["props"]>;
+    adoptedCallback(): void;
+    connectedCallback(): void;
+    disonnectedCallback(): void;
+    attributeChangedCallback(name: ArrayToKeys<STANDARD["observedAttributes"] extends readonly string[] ? STANDARD["observedAttributes"] : never>, oldValue: string | null, newValue: string | null): void;
+    ON: <OBJ extends Record<any, any> & {
+        onConnected?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["connected"];
+        onDisconnected?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["disconnected"];
+        onAdopted?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["adopted"];
+        onAttributeChanged?: NonNullable<Parameters<InstanceType<RET>["ON"]>[1]>["attributeChanged"];
+    }>(obj: OBJ, callbacks?: {
+        connected?: (obj: OBJ) => void;
+        disconnected?: (obj: OBJ) => void;
+        adopted?: (obj: OBJ) => void;
+        attributeChanged?: (obj: OBJ, name: STANDARD["observedAttributes"] extends readonly string[] ? ArrayToKeys<STANDARD["observedAttributes"]> : never, oldValue: string | null, newValue: string | null) => void;
+    }) => OBJ;
+}) & {
+    tagName: string;
+    extendIs: string;
+    namedSlots: STANDARD["namedSlots"];
+    observedAttributes: STANDARD["observedAttributes"];
+    createNamedSlot: typeof WC_createNamedSlot<STANDARD>;
+    props?: STANDARD["props"];
+    define: <TAG extends string, CLASSREF extends CREATEARGS>(tagName: WC_TagName_type<TAG>, classRef: CLASSREF, elementDefinitionOptions?: ElementDefinitionOptions) => ReturnType<typeof WC_createElement_bind<CLASSREF>>;
+}>(Base: BASE_CONSTRUCTOR, staticMember?: STANDARD): RET;
+export type TypeMap = typeof import("../function/IsTypeOf.mjs").TypeMap;
+import type { ArrayToKeys } from '../typehints/ArrayToKeys.mjs';
+import { WC_createElement_bind } from './bindings/WC_createElement_bind.mjs';
+import { WC_createNamedSlot } from './bindings/WC_createNamedSlot.mjs';
+import type { WC_TagName_type } from './common/WC_TagName_type.mjs';