tungsten 0.7.2 → 0.8.0

package/dist-ti/testing/hydrateTestApp.d.ts

@@ -0,0 +1,57 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../Components.jsx';
+import type { TaggedAttributeMismatch } from '../hydrate/renderHydrationMismatchBanner.js';
+import type { TestAppOptions } from './createTestApp.js';
+import { Instance } from '../Instance/Instance.js';
+import { UpdateScheduler } from '../update/UpdateScheduler.js';
+export type HydrateTestAppOptions<Props extends object> = TestAppOptions<Props> & {
+    serverProps?: Props;
+    csr?: boolean;
+};
+type HydrateTestAppArgs<Props extends object> = object extends Props ? [options?: HydrateTestAppOptions<Props>] : keyof Props extends never ? [options?: HydrateTestAppOptions<Props>] : [options: HydrateTestAppOptions<Props> & {
+    props: Props;
+}];
+export type HydrateTestApp<Component extends TungstenBaseComponent> = {
+    readonly document: Document;
+    readonly container: rw HTMLElement;
+    readonly component: rw Component;
+    readonly html: string;
+    readonly mismatches: readonly TaggedAttributeMismatch[];
+    resolved(): Promise<void>;
+    setProps(props: Component['props']): Promise<void>;
+    unmount(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export declare function requireClient: exact ((harness: string) => void);
+export declare function bridgeHappyDomGlobals: exact ((document: Document) => void);
+export declare class HydrateTestAppImplementation<Component extends TungstenBaseComponent> implements HydrateTestApp<Component> {
+    #private;
+    readonly document: Document;
+    readonly container: rw HTMLElement;
+    readonly component: rw Component;
+    readonly html: string;
+    readonly mismatches: readonly TaggedAttributeMismatch[];
+    constructor(document: Document, container: rw HTMLElement, component: rw Component, instance: Instance, scheduler: UpdateScheduler, ownsContainer: boolean, html: string, mismatches: readonly TaggedAttributeMismatch[]);
+    resolved: () => Promise<void>;
+    setProps: (props: Component['props']) => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    unmount: () => Promise<void>;
+}
+/**
+ * The hydration round trip createTestApp() deliberately doesn't cover: render a component to
+ * HTML the way a real server would, parse it with a real HTML parser, hydrate a fresh client
+ * instance against the result, and hand back the live, hydrated component - still fully usable
+ * via setProps()/resolved(), exactly like createTestApp()'s result.
+ *
+ * By default `props` renders on both sides, so a passing test proves an ordinary page hydrates
+ * clean (`mismatches` empty). Pass `serverProps` to diverge the two passes on purpose and assert
+ * on the resulting `mismatches` - the case a one-off "does the reconciler still agree with real
+ * served pages" script never could, because nothing fed it markup that didn't already match.
+ *
+ * A structural mismatch (a different tag, a different number of children) is not something
+ * reconcileHydratedAttributes() can fix - hydrateRootComponent() throws, exactly as the real
+ * client hydrator does, so a caller reproducing that class of bug should assert on the rejection.
+ */
+export declare function hydrateTestApp: exact (<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: HydrateTestAppArgs<Props>) => Promise<HydrateTestApp<Component>>);
+export {};
+//# sourceMappingURL=hydrateTestApp.d.ts.map

package/dist-ti/testing/index.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+export { loadEnv } from './loadEnv.js';
+export { testEnvVariableName } from './testEnvIsRequested.js';
+export { type HydrateTestApp, type HydrateTestAppOptions, hydrateTestApp, } from './hydrateTestApp.js';
+export { type ComponentProps, type CreateTestAppArgs, type TestApp, type TestAppOptions, type TestStore, type TestStoreOverride, type TestStoreRegistration, type TestRoutes, createTestApp, testStore, } from './createTestApp.js';
+export { type HostDontResolveOptions, type HostOptions, type HostResolveOptions, type HostStoreDontResolveOptions, type HostStoreOptions, type HostStoreResolveOptions, type Hosted, type HostedResolved, host, hostGeneric, hostJsx, } from './host.js';
+export { testingComponentPackage } from './testingComponentPackage.js';
+export { contentHtmlElements } from './helpers/contentHtmlElements.js';
+export { ensure } from './ensure.js';
+export { contentToString, type ContentToStringOptions } from './contentToString.js';
+export { makeStore, type TrueStore } from '../Store/makeStore.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-ti/testing/installTestDocInit.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function installTestDocInit: exact (() => void);
+//# sourceMappingURL=installTestDocInit.d.ts.map

package/dist-ti/testing/installTestStyleProcessors.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function installTestStyleProcessors: exact ((moduleName?: string) => void);
+//# sourceMappingURL=installTestStyleProcessors.d.ts.map

package/dist-ti/testing/loadEnv.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+export type LoadEnvOptions = {
+    buildLocation?: string;
+};
+export declare function loadEnv: exact ((options?: LoadEnvOptions) => Promise<void>);
+export declare function waitForEnvIfLoading: exact (() => Promise<void>);
+//# sourceMappingURL=loadEnv.d.ts.map

package/dist-ti/testing/normalize.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=normalize.d.ts.map

package/dist-ti/testing/pipeline/createTestPacketApp.d.ts

@@ -0,0 +1,31 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { Nothing } from '../../pipeline/pipeline.js';
+import type { TestApp } from '../createTestApp.js';
+import type { PipelineTestAppOptions } from './pipelineTestApp.js';
+type Field<K extends string, T, Default> = Default extends T ? {
+    [_ in K]?: T;
+} : {
+    [_ in K]: T;
+};
+export type PacketForComponent<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? Field<'context', Ctx, Nothing> & Field<'networked', N, Nothing> & Field<'allRoutesData', G, undefined> & {
+    routes?: never;
+} : 'invalid component';
+export type TestPacketAppOptions<Props extends object> = PipelineTestAppOptions<Props>;
+export type CreateTestPacketAppArgs<Props extends object> = object extends Props ? [options?: TestPacketAppOptions<Props>] : [options: TestPacketAppOptions<Props> & {
+    props: Props;
+}];
+/**
+ * createTestPipelineApp() with the pipeline's result in place of the pipeline: the component is
+ * handed the packet's context, networked data and all-routes data as they are, with no stages run.
+ * There are no routes; the location still reaches the instance.
+ */
+export declare function createTestPacketApp: exact (<exact Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(packet: PacketForComponent<Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: CreateTestPacketAppArgs<Props>) => Promise<TestApp<Component>>);
+export {};
+//# sourceMappingURL=createTestPacketApp.d.ts.map

package/dist-ti/testing/pipeline/createTestPipelineApp.d.ts

@@ -0,0 +1,71 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { AllRoutesDataConstraint, PipelineApp } from '../../pipeline/pipelineDefinition.js';
+import type { TestApp } from '../createTestApp.js';
+import type { PipelineTestAppOptions } from './pipelineTestApp.js';
+type StageForApp<App> = {
+    routes: (routes: () => []) => App;
+};
+type AppOf<A> = A extends PipelineApp<any, any, any, any> ? A : A extends StageForApp<infer App> ? App : never;
+type AppTypes<A> = AppOf<A> extends PipelineApp<any, infer Ctx, infer N, infer G extends AllRoutesDataConstraint> ? {
+    context: Ctx;
+    networked: N & object;
+    allRoutesData: G;
+} : never;
+export type PipelineAppForComponent<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? PipelineApp<any, Ctx, N, G> : 'invalid component';
+export type PipelineForComponent<C> = PipelineAppForComponent<C> extends infer App ? App extends PipelineApp<any, any, any, any> ? StageForApp<App> : App : never;
+type ComponentReads<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? {
+    context: Ctx;
+    networked: N;
+    allRoutesData: G;
+} : never;
+type DifferingKeys<Made, Read> = {
+    [K in keyof Made & keyof Read]: [Made[K]] extends [Read[K]] ? never : K;
+}[keyof Made & keyof Read];
+type Mismatch<Made, Read> = [DifferingKeys<Made, Read>] extends [never] ? unknown : DifferingKeys<Made, Read> extends infer Ks extends keyof Made & keyof Read ? {
+    'pipeline does not provide required data:': {
+        [K in Ks]: Read[K];
+    };
+    'pipeline provided:': {
+        [K in Ks]: Made[K];
+    };
+} : never;
+export type AppCheck<A, C> = [AppOf<A>] extends [never] ? A extends {
+    clientAllRoutesData: unknown;
+} ? {
+    'add .clientAllRoutesData(): the server makes all-routes data, so the client must': true;
+} : {
+    'not a .routes() app, or a stage .routes() can follow': true;
+} : [ComponentReads<C>] extends [never] ? {
+    'not a tungsten component': true;
+} : Mismatch<AppTypes<A>, ComponentReads<C>>;
+export declare const toApp: (pipelineOrApp: unknown) => PipelineApp;
+export type TestPipelineAppOptions<Props extends object, A = PipelineApp> = PipelineTestAppOptions<Props> & {
+    allRoutesData?: AppTypes<A>['allRoutesData'];
+    networked?: AppTypes<A>['networked'];
+};
+export type TestPipelineApp<Component extends TungstenBaseComponent> = TestApp<Component>;
+export type CreateTestPipelineAppArgs<Props extends object, A = PipelineApp> = object extends Props ? [options?: TestPipelineAppOptions<Props, A>] : [options: TestPipelineAppOptions<Props, A> & {
+    props: Props;
+}];
+/**
+ * createTestApp() for an app built with pipeline() or splitPipeline(): the app's browser stages
+ * run - Init, the all-routes data, Post - and the location is routed against its routes, so the
+ * test sees the context, stores and route the app's own page would. The app is a .routes()
+ * result: the app's own export, a smaller set of routes on the same pipeline, or another pipeline.
+ */
+export declare function createTestPipelineApp: exact (<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, A extends object, RouteData = undefined>(pipelineOrApp: A & AppCheck<A, Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: CreateTestPipelineAppArgs<Props, A>) => Promise<TestPipelineApp<Component>>);
+export {};
+//# sourceMappingURL=createTestPipelineApp.d.ts.map

package/dist-ti/testing/pipeline/hostPipeline.d.ts

@@ -0,0 +1,26 @@
+// @tightscript-object-permissions
+import type { TungstenBaseComponent, TungstenComponentClass, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { ContentNodeElement } from '../../ContentNode.js';
+import type { AppDataOptions, DontResolve, Hosted, HostedResolved, Resolve, ResolveOption, RouteOptions } from '../host.js';
+export type { ComponentApi, Hosted, HostedResolved, HostedRoute, HostStoreOptions, Navigation, StateSetter, } from '../host.js';
+export type HostPipelineOptions = RouteOptions & ResolveOption & AppDataOptions;
+export type HostPipelineResolveOptions = RouteOptions & AppDataOptions & Resolve;
+export type HostPipelineDontResolveOptions = RouteOptions & AppDataOptions & DontResolve;
+type AnyClassComponent = TungstenBaseComponent<any, any>;
+/** host() for a pipeline component: its data comes from the context, so there is no store option */
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineResolveOptions): Promise<HostedResolved<Component>>;
+export declare namespace hostPipeline {
+    export { hostPipelineGeneric as generic };
+    export { hostPipelineJsx as jsx };
+}
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineDontResolveOptions): Promise<Hosted<Component>>;
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineOptions): Promise<HostedResolved<Component> | Hosted<Component>>;
+/** host.generic() with hostPipeline()'s options */
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options?: HostPipelineResolveOptions): (props: Props) => Promise<HostedResolved<Component>>;
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options: HostPipelineDontResolveOptions): (props: Props) => Promise<Hosted<Component>>;
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options?: HostPipelineOptions): (props: Props) => Promise<Hosted<Component> | HostedResolved<Component>>;
+/** host.jsx() with hostPipeline()'s options */
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostPipelineResolveOptions): Promise<HostedResolved<Component>>;
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options: HostPipelineDontResolveOptions): Promise<Hosted<Component>>;
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostPipelineOptions): Promise<Hosted<Component> | HostedResolved<Component>>;
+//# sourceMappingURL=hostPipeline.d.ts.map

package/dist-ti/testing/pipeline/hydrateTestPipelineApp.d.ts

@@ -0,0 +1,31 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { ReqRes } from '../../ReqRes.js';
+import type { TestStoreOverride } from '../createTestApp.js';
+import type { AppCheck } from './createTestPipelineApp.js';
+import type { HydrateTestApp } from '../hydrateTestApp.js';
+export type HydrateTestPipelineAppOptions<Props extends object> = {
+    document?: Document;
+    props?: Props;
+    serverProps?: Props;
+    container?: rw HTMLElement;
+    location?: string;
+    reqRes?: ReqRes;
+    stores?: readonly TestStoreOverride<any>[];
+    fileVersions?: Record<string, string>;
+    csr?: boolean;
+};
+export type HydrateTestPipelineApp<Component extends TungstenBaseComponent> = HydrateTestApp<Component>;
+type HydrateTestPipelineAppArgs<Props extends object> = object extends Props ? [options?: HydrateTestPipelineAppOptions<Props>] : keyof Props extends never ? [options?: HydrateTestPipelineAppOptions<Props>] : [options: HydrateTestPipelineAppOptions<Props> & {
+    props: Props;
+}];
+/**
+ * hydrateTestApp() for an app built with pipeline() or splitPipeline(): the server pass runs the
+ * app's server stages, as a request does, and renders; the page carries the all-routes data and
+ * the networked data; the client pass runs the app's client stages, as hydratePipeline() does, and
+ * hydrates the parsed HTML. So a component whose markup depends on a context only one side makes
+ * shows up in `mismatches`, or throws on a structural difference.
+ */
+export declare function hydrateTestPipelineApp: exact (<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, A extends object, RouteData = undefined>(pipelineOrApp: A & AppCheck<A, Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: HydrateTestPipelineAppArgs<Props>) => Promise<HydrateTestPipelineApp<Component>>);
+export {};
+//# sourceMappingURL=hydrateTestPipelineApp.d.ts.map

package/dist-ti/testing/pipeline/index.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+export { type AppCheck, type CreateTestPipelineAppArgs, type TestPipelineApp, type TestPipelineAppOptions, createTestPipelineApp, } from './createTestPipelineApp.js';
+export { type CreateTestPacketAppArgs, type PacketForComponent, type TestPacketAppOptions, createTestPacketApp, } from './createTestPacketApp.js';
+export { type HydrateTestPipelineApp, type HydrateTestPipelineAppOptions, hydrateTestPipelineApp, } from './hydrateTestPipelineApp.js';
+export { type HostPipelineDontResolveOptions, type HostPipelineOptions, type HostPipelineResolveOptions, type HostStoreOptions, type Hosted, type HostedResolved, type HostedRoute, hostPipeline, hostPipelineGeneric, hostPipelineJsx, } from './hostPipeline.js';
+export { routesOf } from './routesOf.js';
+export { type TestingComponentPackageFromPacketArgs, testingComponentPackageFromPacket, } from './testingComponentPackageFromPacket.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-ti/testing/pipeline/pipelineTestApp.d.ts

@@ -0,0 +1,35 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent } from '../../Components.jsx';
+import type { AsGlobalData, BrandedContext, BrandedNetworkedData } from '../../Brands.js';
+import type { InstancePipeline } from '../../Instance/Instance.js';
+import type { AppRoutes } from '../../routing/AppRoutes.js';
+import type { MatchedRouteInfo } from '../../routing/MatchedRouteInfo.js';
+import type { RoutesWithSettings } from '../../routing/Routes.js';
+import { type TestApp, type TestStoreOverride } from '../createTestApp.js';
+export type PipelineTestAppOptions<Props extends object> = {
+    document?: Document;
+    props?: Props;
+    container?: rw HTMLElement;
+    location?: string;
+    stores?: readonly TestStoreOverride<any>[];
+    fileVersions?: Record<string, string>;
+};
+export type PipelineTestTarget = {
+    document: Document;
+    container: rw HTMLElement;
+    ownsContainer: boolean;
+};
+export type PipelineTestData = {
+    location: string;
+    routes: RoutesWithSettings<any>;
+    appRoutes: AppRoutes<any>;
+    matchedRouteInfo: MatchedRouteInfo;
+    allRoutesData: AsGlobalData;
+    context: BrandedContext;
+    networkedData: BrandedNetworkedData;
+    networked: object;
+    pipeline: InstancePipeline;
+};
+export declare function pipelineTestTarget: exact ((options: PipelineTestAppOptions<object> | undefined, name: string) => PipelineTestTarget);
+export declare function mountPipelineTestApp: exact (<Props extends object, Component extends TungstenBaseComponent, RouteData>(target: PipelineTestTarget, data: PipelineTestData, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, options: PipelineTestAppOptions<Props> | undefined) => Promise<TestApp<Component>>);
+//# sourceMappingURL=pipelineTestApp.d.ts.map

package/dist-ti/testing/pipeline/routesOf.d.ts

@@ -0,0 +1,15 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../../ReqRes.js';
+import type { RoutesWithSettings } from '../../routing/Routes.js';
+import type { PipelineApp } from '../../pipeline/pipelineDefinition.js';
+type InitOf<A> = A extends PipelineApp<infer R> ? R extends (reqRes: any, init: infer I) => unknown ? I : never : never;
+/**
+ * A pipeline app's routes, as host()'s routes option takes them. Given a request, or null, the
+ * app's Init runs for the side isServer says this is - on the server it needs the request - and
+ * the routes get its result. Given Init's result instead, no Init runs. In dev, so a path given
+ * twice fails the test
+ */
+export declare function routesOf<A extends PipelineApp<any>>(app: A, reqRes: ReqRes | null): Promise<RoutesWithSettings<any>>;
+export declare function routesOf<A extends PipelineApp<any>>(app: A, init: InitOf<A>): RoutesWithSettings<any>;
+export {};
+//# sourceMappingURL=routesOf.d.ts.map

package/dist-ti/testing/pipeline/testPipelineRoute.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=testPipelineRoute.d.ts.map

package/dist-ti/testing/pipeline/testingComponentPackageFromPacket.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent } from '../../Components.jsx';
+import type { PacketForComponent } from './createTestPacketApp.js';
+import { type TestingComponentPackageOptions } from '../testingComponentPackage.js';
+export type TestingComponentPackageFromPacketArgs<Props extends object> = object extends Props ? [props?: Props, options?: TestingComponentPackageOptions] : [props: Props, options?: TestingComponentPackageOptions];
+/**
+ * testingComponentPackage() given what a pipeline makes for the component - its context, networked
+ * data and all-routes data - checked against what the component reads, as createTestPacketApp()'s
+ * packet is. The class is only for the types.
+ */
+export declare function testingComponentPackageFromPacket: exact (<Props extends object, Component extends TungstenBaseComponent<any, any>>(packet: PacketForComponent<Component>, _Component: new (pkg: ConstructPackage<Props, undefined>) => Component, ...[props, options]: TestingComponentPackageFromPacketArgs<Props>) => ConstructPackage<Props, undefined>);
+//# sourceMappingURL=testingComponentPackageFromPacket.d.ts.map

package/dist-ti/testing/resolveContent.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+import type { AnyComponent } from '../AnyComponent.js';
+import type { Instance } from '../Instance/Instance.js';
+import type { ContentNode } from '../ContentNode.js';
+/**
+ * The tree as it renders: every component in it constructed and asked for its content, down to
+ * html and text. host({ resolve: true }) hands this back, where host() alone hands back what the
+ * hosted component itself returned, its child components still unexpanded.
+ *
+ * render/contentTreeToRenderingTree does this for the app, but a rendering tree drops a component's
+ * props, keeping only its rendered children. Here a component node stays as written - its type, key
+ * and props - with what it rendered in place of the children it was passed, so a test can read it
+ * by name and by prop as well as by what it put on the page.
+ */
+export declare function resolveContent: exact ((content: ContentNode, parentComponent: AnyComponent | null, instance: Instance, constructed?: Constructed) => Promise<ContentNode>);
+/** On a component node resolveContent resolved: the children it was passed, its own now output */
+export declare const $passedChildren: unique symbol;
+export type Constructed = (component: object) => void;
+//# sourceMappingURL=resolveContent.d.ts.map

package/dist-ti/testing/testEnvIsRequested.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare const testEnvVariableName = "TUNGSTEN_TEST_ENV";
+export declare function testEnvIsRequested: exact ((value: string | undefined) => boolean);
+//# sourceMappingURL=testEnvIsRequested.d.ts.map

package/dist-ti/testing/testingComponentPackage.d.ts

@@ -0,0 +1,36 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseStoreComponentAny } from '../Components.jsx';
+import type { Instance } from '../Instance/Instance.js';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { PartialInternalStoreSchema } from '../Store/InternalStoreSchema.js';
+import type { GlobalData } from '../routing/registerGlobalData.js';
+import { type TrueStore, $trueStoreValue } from '../Store/makeStore.js';
+export type TestingComponentPackageOptions = {
+    store?: Partial<TrueStore<object>>;
+    routes?: object;
+    globalData?: GlobalData;
+    context?: object;
+    networkedData?: object;
+    pipelineNetworked?: object;
+    internalStore?: PartialInternalStoreSchema;
+    config?: Partial<InstanceConfig>;
+    trackWork?: Instance['trackWork'];
+    queueUpdate?: Instance['queueUpdate'];
+    queueTask?: Instance['queueTask'];
+    setTitle?: Instance['setTitle'];
+    goto?: Instance['goto'];
+    redirect?: Instance['redirect'];
+};
+export declare const missingStoreValue: <Value>(key: string) => exact rw {
+    [$trueStoreValue]: true;
+    get: () => Value;
+    set: () => undefined;
+    subscribe: () => undefined;
+    unsubscribe: () => undefined;
+    sync: () => Value;
+    notify: <Fn extends ((value: Value) => void)>(fn: Fn, el: TungstenBaseStoreComponentAny) => Fn;
+    stopNotify: <Fn extends ((value: Value) => void)>(fn: Fn, el: TungstenBaseStoreComponentAny) => Fn;
+    stopNotifyAll: () => undefined;
+};
+export declare const testingComponentPackage: <Props extends object>(props: Props, options?: TestingComponentPackageOptions) => ConstructPackage<Props, undefined>;
+//# sourceMappingURL=testingComponentPackage.d.ts.map

package/dist-ti/throwError.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+export declare function throwError: exact ((location: string, message: string) => never);
+export declare function errorMessage: exact ((location: string, message: string) => string);
+export declare function warnMessage: exact ((location: string, message: string) => string);
+//# sourceMappingURL=throwError.d.ts.map

package/dist-ti/timeProfiler.d.ts

@@ -0,0 +1,17 @@
+// @tightscript-object-permissions
+export type TimeProfiler = {
+    timeProfile: <T>(name: string, task: () => T) => T;
+    timeProfileAsync: <T>(name: string, task: () => T | Promise<T>) => Promise<T>;
+};
+export declare function isProfiling: exact (() => boolean);
+export declare function beginStartupProfiling: exact ((profiling: boolean) => void);
+export declare function reportStartupPhase: exact ((name: string) => void);
+export declare function tallied: exact (<T>(name: string, work: () => T) => T);
+export declare function findTally: exact ((name: string) => {
+    calls: number;
+    ms: number;
+} | undefined);
+export declare function addEndOfRunReport: exact ((report: () => void) => void);
+export declare function reportRunTotal: exact ((name: string) => void);
+export declare function createTimeProfiler: exact ((profiling?: boolean) => TimeProfiler);
+//# sourceMappingURL=timeProfiler.d.ts.map

package/dist-ti/todo.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function todo: exact ((task: string) => void);
+//# sourceMappingURL=todo.d.ts.map

package/dist-ti/update/UpdateResult.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { RenderedContentNode } from '../RenderedContentNode.js';
+export type UpdateResult = {
+    renderedContent: RenderedContentNode;
+    nodesLength: number;
+};
+//# sourceMappingURL=UpdateResult.d.ts.map

package/dist-ti/update/UpdateScheduler.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+export type ScheduledWork = () => void | Promise<void>;
+export declare class UpdateScheduler {
+    #private;
+    readonly maxPasses: number;
+    constructor(maxPasses?: number);
+    enqueueUpdate(key: object, run: ScheduledWork, description: string): void;
+    enqueueTask(run: ScheduledWork, description: string): void;
+    trackWork(run: () => unknown, description: string): void;
+    resolved(): Promise<void>;
+    private resolvePending;
+    private run;
+    private recordError;
+    private throwRecordedError;
+    cancelPending(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=UpdateScheduler.d.ts.map

package/dist-ti/update/guardedUpdate.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+import type { UpdateResult } from './UpdateResult.js';
+export type UpdateGuardHost = {
+    __unmountStarted: boolean;
+    __currentUpdate?: Promise<UpdateResult>;
+    __nextUpdate?: Promise<UpdateResult>;
+    __cancelledUpdateResult: () => UpdateResult;
+};
+export declare function guardedUpdate: exact ((host: rw UpdateGuardHost, run: () => Promise<UpdateResult>) => Promise<UpdateResult>);
+//# sourceMappingURL=guardedUpdate.d.ts.map

package/dist-ti/update/integrateUpdateVdom.d.ts

@@ -0,0 +1,50 @@
+// @tightscript-object-permissions
+import type { Instance } from '../Instance/Instance.js';
+import type { TungstenElement } from '../TungstenElement.js';
+import type { AnyComponent } from '../AnyComponent.js';
+import type { UpdateResult } from './UpdateResult.js';
+import type { TungstenBaseComponent, TungstenBaseComponentType } from '../Components.jsx';
+import type { FunctionComponent } from '../FunctionComponent.js';
+import { DomRegion } from '../DomRegion.js';
+import { DomPointer } from '../DomPointer.js';
+import { type ContentNode, type ContentNodeHtml, type ContentNodeComponentAny } from '../ContentNode.js';
+import { FunctionElement } from '../FunctionComponentStandIn.js';
+import { type $ContentNull } from '../symbols.js';
+import { type RenderedContentNode, type RenderedContentNodeComponent } from '../RenderedContentNode.js';
+export type TungstenHTMLElement = rw HTMLElement & rw {
+    __tungsten_click_handler: (this: HTMLElement, ev: MouseEvent) => any;
+    [key: string]: unknown;
+};
+export declare function integrateElementUpdateVdom: exact ((element: AnyComponent & rw {
+    __currentContent: RenderedContentNode | $ContentNull;
+}, newContent: ContentNode) => Promise<UpdateResult>);
+export type ApplyUpdateArgs = {
+    tungstenElement: AnyComponent;
+    instance: Instance;
+    newNode: ContentNode;
+    oldNode: RenderedContentNode | $ContentNull;
+    domRegion: DomRegion | null;
+    domPointer: DomPointer;
+    parentNode: ContentNode;
+};
+export declare function applyUpdate: exact (({ tungstenElement, instance, newNode, oldNode, domRegion, domPointer, parentNode }: ApplyUpdateArgs) => Promise<RenderedContentNode>);
+export declare function deleteNodeIfRendered: exact ((node: $ContentNull | RenderedContentNode) => void);
+export declare function processHtmlNode: exact ((node: ContentNodeHtml, parentNode: ContentNode) => void);
+type CreateTungstenComponentArgs = {
+    parent: TungstenElement;
+    instance: Instance;
+    node: ContentNodeComponentAny;
+    domPointer: DomPointer;
+};
+export declare function createTungstenComponent: exact (({ parent, instance, node, domPointer }: CreateTungstenComponentArgs) => Promise<RenderedContentNodeComponent>);
+export type MountedTungstenRoot<ComponentType extends TungstenBaseComponentType<any, any>> = {
+    component: InstanceType<ComponentType>;
+    openingComment: Comment;
+    closingComment: Comment;
+};
+export declare function createTungstenRootComponent: exact (<ComponentType extends TungstenBaseComponentType<any, any>>(RootComponent: ComponentType, props: InstanceType<ComponentType>['props'], routeParams: Record<string, string> | undefined, routeData: unknown, instance: Instance, container: HTMLElement) => Promise<MountedTungstenRoot<ComponentType>>);
+export declare function deleteTungstenRoot: exact ((root: MountedTungstenRoot<TungstenBaseComponentType<any, any>>) => void);
+export declare function hotSwapFunctionComponent: exact ((oldElement: FunctionElement<any, any>, NewType: FunctionComponent<any, any>) => Promise<FunctionElement<any, any> | null>);
+export declare function hotSwapClassComponent: exact ((oldElement: TungstenBaseComponent<any, any>, NewType: TungstenBaseComponentType<any, any>) => Promise<TungstenBaseComponent<any, any> | null>);
+export {};
+//# sourceMappingURL=integrateUpdateVdom.d.ts.map

package/dist-ti/update/integrateUpdateVdomPrebuild.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=integrateUpdateVdomPrebuild.d.ts.map

package/dist-ti/update/pendingMounts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Defers mount hooks until the dom they belong to is in the document.
+ *
+ * Elements are assembled off document and inserted once their subtree is complete, which
+ * is what React, Vue and Svelte all do -- appending into an already-attached element makes
+ * the browser invalidate style and layout on every child. The cost is that a component
+ * created part way through that build would see a detached node in componentDidMount, where
+ * getBoundingClientRect returns zeros and .focus() does nothing, failing silently rather
+ * than throwing.
+ *
+ * So creation opens a scope, mount hooks queue inside it, and the scope's owner flushes
+ * them once everything it created has been attached. Hooks are queued as their components
+ * finish creating -- children before parents -- and the queue drains in that order, so a
+ * parent's hook can still rely on its children having mounted.
+ */
+// @tightscript-object-permissions
+export declare function beginMountScope: exact (() => void);
+/**
+ * Runs `hook` when the current scope closes, or immediately if there is no scope -- the
+ * dom is already attached in that case, so there is nothing to wait for.
+ */
+export declare function queueMount: exact ((hook: () => void) => void);
+export declare function endMountScope: exact (() => void);
+/** drops anything still queued -- used when a create pass fails and unwinds */
+export declare function discardPendingMounts: exact (() => void);
+//# sourceMappingURL=pendingMounts.d.ts.map

package/dist-ti/validChildren.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import { type ContentNode, type ContentNodeRendered } from './ContentNode.js';
+import { type RenderingNode, type RenderingNodeRendered } from './RenderingNode.js';
+export declare function validChildren: exact ((children: ContentNode) => children is ContentNodeRendered);
+export declare function validRenderingChildren: exact ((children: RenderingNode) => children is RenderingNodeRendered);
+//# sourceMappingURL=validChildren.d.ts.map

package/dist-ti/warnOnFrameworkChange.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function warnOnFrameworkChange: exact (() => void);
+//# sourceMappingURL=warnOnFrameworkChange.d.ts.map

package/dist-ti/watch.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+type WatchArgs = {
+    dir: string;
+    patterns: string | string[];
+    ignores?: string | string[];
+    handler: (filename: string, event: string) => void | any;
+};
+export declare function watch: exact (({ dir, patterns, ignores, handler }: WatchArgs) => owned rw Promise<unknown>);
+export {};
+//# sourceMappingURL=watch.d.ts.map

package/dist-ti/when.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare function when<A, B>(condition: boolean, value: A, alternate: B): A | B;
+export declare function when<A>(condition: boolean, value: A): A | undefined;
+//# sourceMappingURL=when.d.ts.map