tungsten 0.7.1 → 0.8.0

package/dist-ti/importDevModuleWithRetry.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import { type ModuleNamespace } from './importModule.js';
+export declare function isTransientDevModuleError: exact ((e: unknown) => boolean);
+export declare function importDevModuleWithRetry: exact ((url: string, attempts?: number, delayMs?: number) => Promise<ModuleNamespace>);
+//# sourceMappingURL=importDevModuleWithRetry.d.ts.map

package/dist-ti/importModule.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export type ModuleNamespace = Record<string, unknown>;
+export declare function importModule: exact ((specifier: string) => Promise<ModuleNamespace>);
+//# sourceMappingURL=importModule.d.ts.map

package/dist-ti/index.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+/// <reference path="../types-ti/index.d.ts" preserve="true" />
+export * from './indexInner.js';
+export * as default from './indexInner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-ti/indexInner.d.ts

@@ -0,0 +1,116 @@
+// @tightscript-object-permissions
+export * from './TungstenAppOld.js';
+export { TungstenSimpleComponent, TungstenSimpleComponent as SimpleComponent, // static component
+TungstenStatefulComponent, TungstenStatefulComponent as StatefulComponent, // stateful component
+TungstenSignalsComponent as __TungstenSignalsComponent, TungstenSignalsComponent as __SignalsComponent, TungstenBaseSimpleStoreComponent, TungstenBaseSimpleStoreComponent as BaseSimpleStoreComponent, TungstenBaseStatefulStoreComponent, TungstenBaseStatefulStoreComponent as BaseStatefulStoreComponent, } from './Components.jsx';
+export * from './alive.js';
+export * from './appOutput.js';
+export * from './AssignedStyle.js';
+export * from './clone.js';
+export * from './components/Await.js';
+export * from './components/bindable/BindableCheckbox.jsx';
+export * from './components/bindable/BindableInput.jsx';
+export * from './components/bindable/BindableInputTyped.jsx';
+export * from './components/bindable/BindableRadio.jsx';
+export * from './components/bindable/BindableSelect.jsx';
+export * from './components/bindable/BindableTextarea.jsx';
+export * from './components/Fragment.jsx';
+export * from './components/GoToComponent.jsx';
+export * from './components/Lazy.js';
+export * from './components/Link.jsx';
+export { makeTypedLink } from './components/makeTypedLink.js';
+export * from './components/NativeHtml.jsx';
+export * from './components/NoEscape.jsx';
+export * from './components/PopMessages.jsx';
+export * from './components/Protected.jsx';
+export { type RawHtmlProps, type RawHtmlProps as ParseHtmlProps, RawHtml, RawHtml as ParseHtml, } from './components/RawHtml.jsx';
+export * from './components/RouteRedirectComponent.jsx';
+export { parseHtml, type ParseHtmlOptions } from './rawHtml/parseHtml.js';
+export { safeHtmlAllowList } from './rawHtml/safeHtmlAllowList.js';
+export type { HtmlAllowList } from './rawHtml/HtmlAllowList.js';
+export { sanitizeHtml, type SanitizeHtmlOptions } from './rawHtml/sanitizeHtml.js';
+export { filterContentNode } from './rawHtml/filterContentNode.js';
+export { contentNodeToHtml } from './render/contentNodeToHtml.js';
+export * from './components/WebRedirectComponent.jsx';
+export * from './contentNodeSymbols.js';
+export { pop, dismissPop } from './pop.js';
+export * from './browserStorage.js';
+export { createElement } from './createElement.js';
+export * from './createRef.js';
+export { docInit } from './docInit.js';
+export { foreach } from './foreach.js';
+export * from './helpers/index.js';
+export * from './hooks/index.js';
+export * from './hydrate/hydrate.jsx';
+export * from './jsxHelpers.jsx';
+export { jsx, jsxs, FragmentType, type JsxNodeType } from './jsxRuntime.js';
+export * from './makeServerRpc.js';
+export { isBrowser } from './isBrowser.js';
+export { isClient } from './isClient.js';
+export { isServer } from './isServer.js';
+export { isDev } from './isDev.js';
+export { isProd } from './isProd.js';
+export { logAndReturn } from './logAndReturn.js';
+export * from './requests/index.js';
+export { type GlobalData, type GlobalDataFunction, registerGlobalData, } from './routing/registerGlobalData.js';
+export { registerRoutes } from './routing/registerRoutes.js';
+export { appBuilder, type AppComponents, type AppHelpers } from './appBuilder.js';
+export { registerRouting } from './routing/registerRouting.js';
+export type { RouteEntry, RoutesArray } from './routing/routesArray.js';
+export { pipeline } from './pipeline/pipeline.js';
+export type { PipelineContext, PipelineInit, PipelineNetworked, PipelineResult, PipelineStageContext, PipelineStageResult, } from './pipeline/pipeline.js';
+export type { PipelineApp } from './pipeline/pipelineDefinition.js';
+export { splitPipeline } from './pipeline/splitPipeline.js';
+export type { PipelineServerAllRoutesData } from './pipeline/splitPipeline.js';
+export { contextStore } from './pipeline/contextStore.js';
+export { hydratePipeline } from './pipeline/hydratePipeline.js';
+export { routesWith, routesListWith, makeRouteWith } from './routing/builder.js';
+export { registeredRouting } from './routing/routingRegistry.js';
+export { type Context, type ContextClass, type ContextClasses, registerContext, } from './context/registerContext.js';
+export { registerNetworkedData, type NetworkedData } from './routing/routingRegistry.js';
+export { $kind, type AsContext, type AsNetworkedData, type AsGlobalData } from './Brands.js';
+export { type PrivateEnvSchema, type PublicEnvSchema, registerPrivateEnvSchema, registerPublicEnvSchema, } from './env/registerEnvSchemas.js';
+export * from './routing/builder.js';
+export * from './routing/MatchedRoute.js';
+export * from './routing/RedirectCode.js';
+export * from './routing/Route.jsx';
+export * from './routing/Router.jsx';
+export * from './routing/RouteContentFunction.js';
+export * from './routing/RoutingRedirect.js';
+export * from './routing/WebRedirect.js';
+export * from './when.js';
+export * from './serverRpc.js';
+export * from './settings.js';
+export * from './Store/getStore.js';
+export * from './Store/registerStore.js';
+export * from './components/Stylesheet.jsx';
+export { TungstenError } from './TungstenError.js';
+export * from './__deproxy.js';
+export { $original } from './componentProxyHandlers.js';
+export type { Request } from './api/Request.js';
+export type { Response } from './api/Response.js';
+export type { BindVariable, TypedBindVariable } from './components/bindable/BindVariable.js';
+export type { ConstructPackage, TungstenBaseComponentType } from './Components.jsx';
+export * from './ContentNode.js';
+export type { GenericObject } from './GenericObject.type.js';
+export type { Instance } from './Instance/Instance.js';
+export type { Key } from './Key.js';
+export type { PopMessage } from './PopMessage.type.js';
+export type { ReqRes, ReqResOrNull } from './ReqRes.js';
+export type { MatchedRouteInfo } from './routing/MatchedRouteInfo.ts';
+export type { Params } from './routing/Params.js';
+export type { ParamsFromPath } from './routing/ParamsFromPath.js';
+export type { RoutePaths, PathTemplate } from './routing/RoutePaths.js';
+export { type Endpoint, type Route, type Route as RouteType, type RouteKey, type Path, type Path as RoutePath, StringIsPath, RouteKeyIsPath, } from './routing/RouteTypes.js';
+export type { Routes, CustomRoutes } from './routing/Routes.js';
+export { $cacheControl, type CacheControl, type RouteCacheControl } from './cacheControl.js';
+export type { ErrorRouteType } from './routing/ErrorRouteType.js';
+export { makeTungstenErrorInfo, type TungstenErrorInfo } from './routing/TungstenErrorInfo.js';
+export type { RouteParams } from './routing/RouteParams.type.js';
+export type { RouteData } from './routing/RouteData.js';
+export type { RouteDataFunction } from './routing/RouteDataFunction.type.js';
+export type { RouteDataReturnType } from './routing/RouteDataReturnType.js';
+export type { FrameworkConfig, FrameworkConfig as Config } from './FrameworkConfig.js';
+export type { TungstenComponentPropsBase, TungstenComponentPropsBase as PropsBase, TungstenComponentStateConstraint, TungstenComponentStateConstraint as StateConstraint, ComponentStore, } from './Components.jsx';
+export type { CssNames } from './CssNames.js';
+//# sourceMappingURL=indexInner.d.ts.map

package/dist-ti/info.d.ts

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

package/dist-ti/innerHtmlFromProps.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+/**
+ * Reads React's `dangerouslySetInnerHTML` prop, returning the raw markup, or
+ * `null` when the element does not use it.
+ *
+ * The markup is the element's entire inner content: the server writes it into
+ * its HTML verbatim, the client assigns it to `innerHTML`, and the nodes the
+ * parser produces from it are never reconciled. Tungsten holds one opaque
+ * string where the DOM holds a whole subtree, so reconciling them would
+ * corrupt the document.
+ *
+ * `hasChildren` is supplied by the caller because the content and rendering
+ * trees test their children differently.
+ */
+export declare function innerHtmlFromProps: exact ((type: string, props: {
+    dangerouslySetInnerHTML?: unknown;
+    [key: string]: unknown;
+}, hasChildren: boolean) => string | null);
+//# sourceMappingURL=innerHtmlFromProps.d.ts.map

package/dist-ti/isBrowser.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export { isClient as isBrowser } from './isClient.js';
+//# sourceMappingURL=isBrowser.d.ts.map

package/dist-ti/isClient.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const isClient: boolean;
+//# sourceMappingURL=isClient.d.ts.map

package/dist-ti/isDev.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+declare let isDev: boolean;
+export { isDev };
+//# sourceMappingURL=isDev.d.ts.map

package/dist-ti/isProd.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const isProd: boolean;
+//# sourceMappingURL=isProd.d.ts.map

package/dist-ti/isServer.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const isServer: boolean;
+//# sourceMappingURL=isServer.d.ts.map

package/dist-ti/iterationQueryString.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function iterationQueryString: exact ((target: string, iteration: number, namespace?: string) => string);
+//# sourceMappingURL=iterationQueryString.d.ts.map

package/dist-ti/json.d.ts

@@ -0,0 +1,17 @@
+// @tightscript-object-permissions
+import type { Json } from './Json.type.js';
+type Replacer = (this: unknown, key: string, value: unknown) => unknown;
+type Reviver = (this: unknown, key: string, value: unknown) => unknown;
+type AllowList = (string | number)[] | null;
+type Space = string | number;
+type IfAny<T, Then> = 0 extends (1 & T) ? Then : never;
+export declare function JSONstringify<T>(value: T & IfAny<T, unknown>, replacer?: Replacer | AllowList, space?: Space): string | undefined;
+export declare function JSONstringify(value: undefined | symbol | ((...args: never[]) => unknown), replacer?: Replacer | AllowList, space?: Space): undefined;
+export declare function JSONstringify(value: object, replacer?: AllowList, space?: Space): string;
+export declare function JSONstringify(value: string | number | boolean | null, replacer?: AllowList, space?: Space): string;
+export declare function JSONstringify(value: string | number | boolean | null | object, replacer?: AllowList, space?: Space): string;
+export declare function JSONstringify(value: unknown, replacer?: Replacer | AllowList, space?: Space): string | undefined;
+export declare function JSONparse(text: string): Json;
+export declare function JSONparse(text: string, reviver: Reviver): unknown;
+export {};
+//# sourceMappingURL=json.d.ts.map

package/dist-ti/jsx-runtime.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export { jsx, jsxs, Fragment, type JsxNodeType } from './jsxRuntime.js';
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist-ti/jsxHelpers.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare const sp = " ";
+export declare const nbsp: rw import("./ContentNode.js").ContentNodeClassComponent | rw import("./ContentNode.js").ContentNodeFragment | rw import("./ContentNode.js").ContentNodeFunctionComponent | rw import("./ContentNode.js").ContentNodeHtml;
+//# sourceMappingURL=jsxHelpers.d.ts.map

package/dist-ti/jsxRuntime.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { AnyComponentType } from './AnyComponentType.js';
+import type { KeyAttr } from './KeyAttr.js';
+import type { ContentNode, NodeProps } from './ContentNode.js';
+export * from './contentNodeSymbols.js';
+export declare const Fragment: symbol;
+export { Fragment as FragmentType };
+export type JsxNodeType = string | AnyComponentType | typeof Fragment;
+export declare function jsx: exact ((type: JsxNodeType | string | number | boolean | null | undefined, props: rw NodeProps, key: KeyAttr) => ContentNode);
+export declare const jsxs: (...args: Parameters<typeof jsx>) => ContentNode;
+//# sourceMappingURL=jsxRuntime.d.ts.map

package/dist-ti/jsxRuntimeSignals.d.ts

@@ -0,0 +1,23 @@
+// @tightscript-object-permissions
+import type { AnyComponentType } from './AnyComponentType.js';
+import type { TungstenComponentGenericProps } from './Components.jsx';
+import type { KeyAttr } from './KeyAttr.js';
+export * from './contentNodeSymbols.js';
+export declare const Fragment: symbol;
+export type JsxNodeType = string | AnyComponentType | typeof Fragment;
+export declare const TypeSymbol: unique symbol;
+export declare function jsx: exact ((type: JsxNodeType | string | number | boolean | null | undefined, props: rw TungstenComponentGenericProps, key: KeyAttr) => string | exact rw {
+    type: symbol;
+    props: rw TungstenComponentGenericProps;
+    key: KeyAttr;
+} | exact rw {
+    type: (r import("./FunctionComponent.js").FunctionComponent<any, any> & rw Function) | (r import("./Components.jsx").TungstenBaseComponentType<any, any> & rw Function);
+    props: rw TungstenComponentGenericProps;
+    key: KeyAttr;
+} | exact rw {
+    type: string;
+    props: rw TungstenComponentGenericProps;
+    key: KeyAttr;
+} | null);
+export declare const jsxs: exact typeof jsx;
+//# sourceMappingURL=jsxRuntimeSignals.d.ts.map

package/dist-ti/loadPackageDotJsonFromDir.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Json } from './Json.type.js';
+export declare function loadPackageDotJsonFromDir: exact ((dir: string) => rw Promise<Json>);
+//# sourceMappingURL=loadPackageDotJsonFromDir.d.ts.map

package/dist-ti/logAndReturn.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare function logAndReturn<A>(a: A): A;
+export declare function logAndReturn<A, B>(a: A, b: B): B;
+//# sourceMappingURL=logAndReturn.d.ts.map

package/dist-ti/makeFinalConfig.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { FrameworkConfig, FrameworkConfigComplete, FrameworkConfigOverrides } from './FrameworkConfig.js';
+export declare function makeFinalConfig: exact ((userConfig: FrameworkConfig, overrides?: FrameworkConfigOverrides | null) => FrameworkConfigComplete);
+//# sourceMappingURL=makeFinalConfig.d.ts.map

package/dist-ti/makeInstanceConfigFromFrameworkConfig.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { InstanceConfig } from './Instance/InstanceConfig.js';
+import type { FrameworkConfigComplete } from './FrameworkConfig.js';
+export declare function makeInstanceConfigFromFrameworkConfig: exact ((frameworkConfig: FrameworkConfigComplete, dev?: boolean) => InstanceConfig);
+//# sourceMappingURL=makeInstanceConfigFromFrameworkConfig.d.ts.map

package/dist-ti/makeServerRpc.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+type TypeValidator<I> = (input: unknown) => I;
+type AnyFunction = (...args: any[]) => any;
+export declare const makeServerRpcUnchecked: <F extends AnyFunction>(serverFunction: F) => F;
+type ServerFunction<I> = (input: I) => any;
+export declare const makeServerRpcChecked: <I>(typeValidator: TypeValidator<I>, serverFunction: ServerFunction<I>) => ServerFunction<I>;
+export {};
+//# sourceMappingURL=makeServerRpc.d.ts.map

package/dist-ti/markOptionSelected.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+type OptionProps = {
+    children?: unknown;
+    value?: unknown;
+    selected?: unknown;
+};
+/**
+ * Marks an <option> as the one its enclosing <select> has chosen, given that select's value.
+ *
+ * Every renderer needs this, not just the server: markup is the only way the server can express
+ * a selection, so the client's content tree has to carry the same prop or hydration reconciles
+ * the server's `selected` attribute away as an attribute the client never rendered.
+ */
+export declare function markOptionSelected: exact ((props: OptionProps & rw {
+    selected?: unknown;
+}, selectValue: unknown) => void);
+export {};
+//# sourceMappingURL=markOptionSelected.d.ts.map

package/dist-ti/mergeConfigs.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { FrameworkConfig } from './FrameworkConfig.js';
+export declare function mergeConfigs: exact ((config1: Partial<FrameworkConfig>, config2: Partial<FrameworkConfig>) => Partial<FrameworkConfig>);
+//# sourceMappingURL=mergeConfigs.d.ts.map

package/dist-ti/moduleReloader.d.ts

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

package/dist-ti/mutatingFunctions.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+export declare const arrayMutatingFunctions: readonly ['push', 'pop', 'shift', 'unshift', 'sort', 'splice', 'reverse', 'fill', 'copyWithin'];
+type ArrayMutatingFunctions = typeof arrayMutatingFunctions[number];
+export declare const arrayMutatingFunctionInsertsFrom: Partial<Record<ArrayMutatingFunctions, number>>;
+export declare const mapMutatingFunctions: readonly ['set', 'delete', 'clear'];
+type MapMutatingFunctions = typeof mapMutatingFunctions[number];
+export declare const setMutatingFunctions: readonly ['add', 'delete', 'clear'];
+type SetMutatingFunctions = typeof setMutatingFunctions[number];
+export declare function KeyIsArrayMutatingFunction: exact ((key: string) => key is ArrayMutatingFunctions);
+export declare function KeyIsMapMutatingFunction: exact ((key: string) => key is MapMutatingFunctions);
+export declare function KeyIsSetMutatingFunction: exact ((key: string) => key is SetMutatingFunctions);
+export {};
+//# sourceMappingURL=mutatingFunctions.d.ts.map

package/dist-ti/nbsp.d.ts

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

package/dist-ti/objectMap.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export type ObjectMapFunction<O extends object> = (key: keyof O, value: any, object: object) => unknown;
+export declare function objectMap: exact (<O extends object>(object: O, func: ObjectMapFunction<O>) => Record<keyof O, any>);
+//# sourceMappingURL=objectMap.d.ts.map

package/dist-ti/objectTypesToCopy.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const objectTypesToCopy: exact rw string[];
+//# sourceMappingURL=objectTypesToCopy.d.ts.map

package/dist-ti/objectTypesToProxy.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const objectTypesToProxy: exact rw string[];
+//# sourceMappingURL=objectTypesToProxy.d.ts.map

package/dist-ti/output.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+export declare function out: exact ((...inputs: unknown[]) => void);
+export declare function note: exact ((...inputs: unknown[]) => void);
+export declare function log: exact ((...inputs: unknown[]) => void);
+export declare function warn: exact ((...texts: any[]) => void);
+export declare function errorOut: exact ((...texts: any[]) => void);
+//# sourceMappingURL=output.d.ts.map

package/dist-ti/packageSettings.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const configName = "tungsten.config";
+//# sourceMappingURL=packageSettings.d.ts.map

package/dist-ti/pipeLog.d.ts

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

package/dist-ti/pipeline/contextStore.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import type { SubscribedElements } from '../Store/StoreSubscriptions.types.js';
+import { type TrueStore } from '../Store/makeStore.js';
+export type StoreSync = 'afterRouting' | 'afterRender';
+export type ContextStoreSettings = {
+    sync: StoreSync;
+    subscribedElements: SubscribedElements;
+};
+export declare const contextStore: <Schema extends object>(values: Schema, options?: {
+    sync?: StoreSync;
+}) => TrueStore<Schema>;
+export declare const contextStoreSettings: (store: object) => r ContextStoreSettings | undefined;
+//# sourceMappingURL=contextStore.d.ts.map

package/dist-ti/pipeline/hydratePipeline.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { TungstenBaseComponentType } from '../Components.jsx';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+export declare function hydratePipeline: exact ((app: unknown, RootComponent: TungstenBaseComponentType | null, instanceConfig: InstanceConfig, fileVersions?: Record<string, string>) => rw Promise<void>);
+//# sourceMappingURL=hydratePipeline.d.ts.map

package/dist-ti/pipeline/importRoutesModule.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { PipelineApp } from './pipelineDefinition.js';
+export declare function importRoutesModule: exact ((compilationInfo: CompilationInfo, config: FrameworkConfigComplete, iteration: number | null) => Promise<PipelineApp>);
+export declare function pipelineAppFrom: exact ((module: unknown, routesLocation: FrameworkConfigComplete['routesLocation']) => PipelineApp);
+//# sourceMappingURL=importRoutesModule.d.ts.map

package/dist-ti/pipeline/networkedTransport.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+export declare class NetworkedTransport {
+    #private;
+    readonly networked: object | undefined;
+    constructor(networked: object | undefined);
+    snapshotAfterRouting(): void;
+    toJSON(): owned rw {
+        [k: string]: unknown;
+    };
+}
+export declare function fromTransport: exact ((half: object | undefined) => object | undefined);
+//# sourceMappingURL=networkedTransport.d.ts.map

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

@@ -0,0 +1,124 @@
+// @tightscript-object-permissions
+import type { ComponentStore, ConstructPackage, TungstenComponentPropsBase, TungstenComponentSignalsConstraint, TungstenComponentStateConstraint } from '../Components.jsx';
+import type { ComponentHelpers } from '../componentHelpers.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+import type { ExactRoutesWithSettings } from '../routing/Routes.js';
+import type { DataRedirect } from '../routing/DataRedirect.js';
+import type { NoDuplicatePaths, RoutesArray } from '../routing/routesArray.js';
+import type { Serializable } from '../routing/Serializable.js';
+import type { ReadonlyTrueStore } from '../Store/makeStore.js';
+import type { MaybePromise, PipelineApp, PipelineDefinition, RoutesOptions, ServerKind, ServerRequests, StageContext } from './pipelineDefinition.js';
+import { TungstenBaseSimpleStoreComponent, TungstenBaseStatefulStoreComponent, TungstenSignalsComponent, TungstenSimpleComponent, TungstenStatefulComponent } from '../Components.jsx';
+type Props = TungstenComponentPropsBase;
+type State = TungstenComponentStateConstraint;
+type Signals = TungstenComponentSignalsConstraint;
+export type Nothing = Record<never, never>;
+export type DeliveredContext<Ctx> = Ctx extends object ? Ctx : Nothing;
+export type PipelineHelpers<Ctx, N, G extends object | undefined> = Omit<ComponentHelpers, 'context' | 'allRoutesData' | 'networked'> & {
+    readonly context: DeliveredContext<Ctx>;
+    readonly networked: N & object;
+    readonly allRoutesData: G;
+};
+export declare abstract class PipelineSimpleComponent<Ctx, N, G extends object | undefined, P extends Props = Props, RD = undefined> extends TungstenSimpleComponent<P, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+}
+export declare abstract class PipelineStatefulComponent<Ctx, N, G extends object | undefined, P extends Props, S extends State, RD = undefined> extends TungstenStatefulComponent<P, S, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+}
+export declare abstract class PipelineSignalsComponent<Ctx, N, G extends object | undefined, P extends Props, Sg extends Signals, RD = undefined> extends TungstenSignalsComponent<P, Sg, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+}
+type SelectStore<Ctx, N, G extends object | undefined, Schema extends object> = (context: PipelineHelpers<Ctx, N, G>['context'], networked: N) => ReadonlyTrueStore<Schema>;
+export declare abstract class PipelineSimpleStoreComponent<Ctx, N, G extends object | undefined, St extends object, P extends Props = Props, RD = undefined> extends TungstenBaseSimpleStoreComponent<P, RD, St> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+    protected createStore<Schema extends object>(select: SelectStore<Ctx, N, G, Schema>): ComponentStore<Schema>;
+}
+export declare abstract class PipelineStatefulStoreComponent<Ctx, N, G extends object | undefined, St extends object, P extends Props, S extends State, RD = undefined> extends TungstenBaseStatefulStoreComponent<P, S, RD, St> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+    protected createStore<Schema extends object>(select: SelectStore<Ctx, N, G, Schema>): ComponentStore<Schema>;
+}
+type Statics<T> = Omit<T, 'prototype'>;
+export type PipelineComponents<Ctx, N, G extends object | undefined> = {
+    SimpleComponent: (abstract new <P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleComponent<Ctx, N, G, P, RD>) & Statics<typeof PipelineSimpleComponent>;
+    StatefulComponent: (abstract new <P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulComponent<Ctx, N, G, P, S, RD>) & Statics<typeof PipelineStatefulComponent>;
+    SignalsComponent: (abstract new <P extends Props = Props, Sg extends Signals = Signals, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSignalsComponent<Ctx, N, G, P, Sg, RD>) & Statics<typeof PipelineSignalsComponent>;
+    SimpleStoreComponent: (abstract new <St extends object, P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleStoreComponent<Ctx, N, G, St, P, RD>) & Statics<typeof PipelineSimpleStoreComponent>;
+    StatefulStoreComponent: (abstract new <St extends object, P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulStoreComponent<Ctx, N, G, St, P, S, RD>) & Statics<typeof PipelineStatefulStoreComponent>;
+};
+type StageTypes<X> = X extends {
+    SimpleStoreComponent: abstract new (...args: any) => PipelineSimpleStoreComponent<infer Ctx, infer N, any, object, any, any>;
+} ? {
+    context: Ctx extends object ? Ctx : Nothing;
+    networked: N;
+} : never;
+export type PipelineContext<X> = StageTypes<X>['context'];
+export type PipelineNetworked<X> = StageTypes<X>['networked'];
+export type PipelineResult<X> = StageTypes<X>;
+export type PipelineInit<X> = X extends {
+    routes: Routes<any, infer I, any, any, any>;
+} ? I : never;
+declare const $stage: unique symbol;
+type StageRecord<Result, Ctx> = {
+    result: Result;
+    context: Ctx;
+};
+type Marked<Result, Ctx, Stages> = {
+    readonly [$stage]?: StageRecord<Result, Ctx> & {
+        stages: Stages;
+    };
+};
+type StagesOf<X> = X extends {
+    readonly [$stage]?: {
+        stages: infer S;
+    };
+} ? S : unknown;
+export type StageMark<This, Name extends string, Result, Ctx> = Marked<Result, Ctx, StagesOf<This> & {
+    [K in Name]: StageRecord<Result, Ctx>;
+}>;
+type OwnRecord<X> = X extends Marked<infer R, infer C, any> ? StageRecord<R, C> : never;
+type RecordOf<X, Name> = [Name] extends [never] ? OwnRecord<X> : Name extends keyof StagesOf<X> ? StagesOf<X>[Name] : never;
+export type PipelineStageResult<X, Name extends keyof StagesOf<X> = never> = RecordOf<X, Name> extends StageRecord<infer R, any> ? R : never;
+export type PipelineStageContext<X, Name extends keyof StagesOf<X> = never> = RecordOf<X, Name> extends StageRecord<any, infer C> ? (C extends object ? C : Nothing) : never;
+type Process<Req, Previous, X, G = never> = (reqRes: Req | null, previous: Previous, allRoutesData: G) => MaybePromise<X>;
+export type SerializableData<G> = G extends object ? Serializable<G> : never;
+export type AllRoutesDataProcess<Req, I, G> = (reqRes: Req | null, init: I, location: string) => MaybePromise<(G & SerializableData<NoInfer<G>>) | DataRedirect>;
+export type AllRoutesDataFallback<Req, I, G> = NoInfer<G> | ((reqRes: Req | null, init: I, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
+export type RoutesReturn<G extends object | undefined> = ExactRoutesWithSettings<G> | RoutesArray<G> | [];
+type RoutesFunction<Req, I, Rs> = (reqRes: Req | null, init: I) => Rs;
+type HasErrorRoute<Rs> = Rs extends readonly unknown[] ? (number extends Rs['length'] ? true : ('error' extends PathOf<Rs[number]> ? true : false)) : ('error' extends keyof Rs ? true : false);
+type PathOf<E> = E extends {
+    path: infer P;
+} ? P : never;
+type ReturnedRoutes<R> = R extends (...args: never[]) => infer Rs ? Rs : R;
+export type RequireErrorRoute<R> = true extends HasErrorRoute<ReturnedRoutes<R>> ? unknown : 'A pipeline needs an \'error\' route: a failed request renders it.';
+type Routes<Req, I, Ctx, N, G extends object | undefined> = {
+    <const exact Rs extends RoutesReturn<G>>(routes: RoutesFunction<Req, I, Rs> & NoDuplicatePaths<Rs> & RequireErrorRoute<Rs>): PipelineApp<RoutesFunction<Req, I, Rs>, DeliveredContext<Ctx>, N, G>;
+    <const exact Rs extends RoutesReturn<G>>(options: RoutesOptions, routes: RoutesFunction<Req, I, Rs> & NoDuplicatePaths<Rs> & RequireErrorRoute<Rs>): PipelineApp<RoutesFunction<Req, I, Rs>, DeliveredContext<Ctx>, N, G>;
+};
+export type ErrorPageComponent<ECtx, EN, G extends object | undefined> = PipelineSimpleComponent<ECtx, EN, G | undefined, TungstenErrorInfo>;
+export type ErrorPageClass<ECtx, EN, G extends object | undefined> = abstract new (pkg: ConstructPackage<TungstenErrorInfo, undefined>) => ErrorPageComponent<ECtx, EN, G>;
+export type RoutesStage<Req, I, Ctx, N, G extends object | undefined, ECtx, EN> = PipelineComponents<Ctx, N, G> & {
+    ErrorComponent: ErrorPageClass<ECtx, EN, G> & Statics<typeof PipelineSimpleComponent>;
+    routes: Routes<Req, I, Ctx, N, G>;
+};
+export type PostStage<Req, I, Ctx, N, G extends object | undefined, ECtx = I, EN = Nothing> = RoutesStage<Req, I, Ctx, N, G, ECtx, EN> & {
+    errorPage: (page: ErrorPageClass<ECtx, EN, G>) => RoutesStage<Req, I, Ctx, N, G, ECtx, EN>;
+};
+export type DataStage<Req, I, G extends object | undefined> = PostStage<Req, I, I, Nothing, G> & {
+    post: <P extends StageContext, This>(this: This, process: Process<Req, I, P, G>) => PostStage<Req, I, P, Nothing, G> & StageMark<This, 'post', P, P>;
+};
+export type InitStage<Req, I> = DataStage<Req, I, undefined> & {
+    allRoutesData: <G extends object, This>(this: This, process: AllRoutesDataProcess<Req, I, G>, fallback?: AllRoutesDataFallback<Req, I, G>) => DataStage<Req, I, G> & StageMark<This, 'allRoutesData', G, I>;
+};
+export type ServerStage<Req> = InitStage<Req, undefined> & {
+    init: <I extends StageContext | undefined, This>(this: This, process: Process<Req, undefined, I>) => InitStage<Req, I> & StageMark<This, 'init', I, I>;
+};
+export declare const loosely: <T>(process: unknown) => T;
+export declare function postStage: exact (<Req, I, Ctx, N, G extends object | undefined, ECtx = I, EN = Nothing>(definition: PipelineDefinition) => PostStage<Req, I, Ctx, N, G, ECtx, EN>);
+export declare function checkServer: exact ((builder: string, lib: ServerKind) => void);
+export type PipelineBuilder = {
+    server: <Kind extends ServerKind>(kind: Kind) => ServerStage<ServerRequests[Kind]>;
+};
+export declare const pipeline: PipelineBuilder;
+export {};
+//# sourceMappingURL=pipeline.d.ts.map