tungsten 0.7.1 → 0.8.0

package/dist-ti/componentClassName.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const componentBumpClass = "__c__";
+//# sourceMappingURL=componentClassName.d.ts.map

package/dist-ti/componentHelpers.d.ts

@@ -0,0 +1,20 @@
+// @tightscript-object-permissions
+import type { Instance } from './Instance/Instance.js';
+import type { Routes } from './routing/Routes.js';
+import type { Context } from './context/registerContext.js';
+import type { GlobalData } from './routing/registerGlobalData.js';
+import type { NetworkedData } from './routing/routingRegistry.js';
+export type ComponentHelpers = {
+    fileUrl: (path: `/${string}`) => string;
+    getRoutes: <exact R extends Routes<any> = Routes>() => R;
+    readonly context: Context;
+    readonly globalData: GlobalData;
+    readonly allRoutesData: GlobalData | undefined;
+    readonly networkedData: NetworkedData;
+    readonly networked: object;
+    readonly instance: Instance;
+};
+export declare function makeComponentHelpers: exact ((component: {
+    __instance: Instance;
+}) => ComponentHelpers);
+//# sourceMappingURL=componentHelpers.d.ts.map

package/dist-ti/componentProxyHandlers.d.ts

@@ -0,0 +1,39 @@
+// @tightscript-object-permissions
+export type StateOwner = {
+    __initialized: boolean;
+    __signals: boolean;
+    __stateUpdated: () => void;
+    constructor: {
+        name: string;
+    };
+};
+export declare const $original: unique symbol;
+export declare const $ownerName: unique symbol;
+export declare const getStateProxyHandler: <State extends rw object>(element: StateOwner) => exact rw {
+    get: (obj: State, key: string | symbol) => unknown;
+    set: (obj: State, key: string | symbol, value: lazy all unknown) => boolean;
+    deleteProperty: (obj: State, key: string | symbol) => boolean;
+    has(obj: State, key: string | symbol): boolean;
+    ownKeys(obj: State): r (string | symbol)[];
+};
+declare const makeStateObjectProxyHandler: <O extends rw object>(element: StateOwner) => exact rw {
+    get: (obj: O, key: string | symbol) => unknown;
+    set: (obj: O, key: string | symbol, value: lazy all unknown) => boolean;
+    deleteProperty: (obj: O, key: string | symbol) => boolean;
+    has(obj: O, key: string | symbol): boolean;
+    ownKeys(obj: O): r (string | symbol)[];
+};
+export declare const getStateObjectProxyHandler: <O extends rw object>(element: StateOwner) => ReturnType<typeof makeStateObjectProxyHandler<O>>;
+export declare const getStateArrayProxyHandler: r ((element: StateOwner) => r ProxyHandler<rwd unknown[]>);
+export declare const getStateMapProxyHandler: r ((element: StateOwner) => exact rw {
+    get: (map: Map<unknown, unknown>, key: string | symbol, receiver: unknown) => string | number | r Map<unknown, unknown> | ((callbackfn: r ((value: unknown, key: unknown, map: r Map<unknown, unknown>) => void), thisArg?: any) => void);
+    has(map: Map<unknown, unknown>, key: string | symbol): boolean;
+});
+export declare const getStateSetProxyHandler: r ((element: StateOwner) => exact rw {
+    get: (set: Set<unknown>, key: string | symbol, receiver: unknown) => string | number | r Set<unknown> | ((callbackfn: r ((value: unknown, value2: unknown, set: r Set<unknown>) => void), thisArg?: any) => void);
+    has(set: Set<unknown>, key: string | symbol): boolean;
+});
+export declare function proxyObjectContent: exact (<O extends object>(element: StateOwner, object: O, adopted?: WeakMap<object, object>) => void);
+export declare function proxyArrayContent: exact (<A extends rw unknown[]>(element: StateOwner, array: A, adopted?: WeakMap<object, object>) => void);
+export {};
+//# sourceMappingURL=componentProxyHandlers.d.ts.map

package/dist-ti/componentType.d.ts

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

package/dist-ti/components/Await.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+import { TungstenStatefulComponent, type TungstenComponentPropsBase } from '../Components.jsx';
+type AwaitProps = TungstenComponentPropsBase & {
+    promise: Promise<unknown>;
+    children?: ContentNode | ((result?: unknown) => ContentNode);
+};
+type AwaitState = rw {
+    done: boolean;
+    result: unknown;
+};
+export declare class Await extends TungstenStatefulComponent<AwaitProps, AwaitState> {
+    state: rw AwaitState;
+    init: () => void;
+    content: () => ContentNode;
+}
+export {};
+//# sourceMappingURL=Await.d.ts.map

package/dist-ti/components/Fragment.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+export declare function Fragment: exact (({ children }: {
+    children: ContentNode;
+}) => ContentNode);
+export declare function Jsx: exact (({ children }: {
+    children: ContentNode;
+}) => ContentNode);
+//# sourceMappingURL=Fragment.d.ts.map

package/dist-ti/components/GoToComponent.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { RouteKey } from '../routing/RouteTypes.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+type Props = {
+    to: RouteKey;
+};
+export declare class GoTo extends TungstenSimpleComponent<Props> {
+    content: () => null;
+}
+export {};
+//# sourceMappingURL=GoToComponent.d.ts.map

package/dist-ti/components/Lazy.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+import { TungstenStatefulComponent, type TungstenComponentPropsBase } from '../Components.jsx';
+type AwaitProps = TungstenComponentPropsBase & {
+    promise: Promise<any>;
+    children?: ContentNode | ((result?: any) => ContentNode);
+};
+type AwaitState = rw {
+    done: boolean;
+    result?: unknown;
+};
+export declare class Lazy extends TungstenStatefulComponent<AwaitProps, AwaitState> {
+    state: rw AwaitState;
+    init: () => void;
+    content: () => ContentNode;
+}
+export {};
+//# sourceMappingURL=Lazy.d.ts.map

package/dist-ti/components/Link.d.ts

@@ -0,0 +1,15 @@
+// @tightscript-object-permissions
+import type { AnchorMouseEvent } from '../../types/jsx/html.events.js';
+import type { ContentNode } from '../ContentNode.js';
+import type { Path } from '../routing/RouteTypes.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export type LinkProps<To extends Path = Path> = {
+    className?: string | undefined;
+    to: To;
+    children: ContentNode;
+};
+export declare class Link<To extends Path = Path> extends TungstenSimpleComponent<LinkProps<To>> {
+    click: (event: AnchorMouseEvent) => void;
+    content: () => owned rw import("../ContentNode.js").ContentNodeClassComponent | owned rw import("../ContentNode.js").ContentNodeFragment | owned rw import("../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../ContentNode.js").ContentNodeHtml;
+}
+//# sourceMappingURL=Link.d.ts.map

package/dist-ti/components/NativeHtml.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { ContentNodeHtml } from '../ContentNode.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export interface NativeHtmlProps {
+    children: ContentNodeHtml | ContentNodeHtml[];
+}
+export declare class NativeHtml extends TungstenSimpleComponent<NativeHtmlProps> {
+    static __opaque: boolean;
+    content: () => r (r ContentNodeHtml)[] | r ContentNodeHtml;
+}
+//# sourceMappingURL=NativeHtml.d.ts.map

package/dist-ti/components/NoEscape.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+export type NoEscapeProps = {
+    children: string;
+};
+export declare function NoEscape({ children }: NoEscapeProps): string;
+export declare namespace NoEscape {
+    var noEscape: boolean;
+}
+//# sourceMappingURL=NoEscape.d.ts.map

package/dist-ti/components/PopMessages.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import { TungstenSimpleInternalStoreComponent } from '../Components.jsx';
+type Props = {
+    className?: string;
+    messageClassName?: string;
+    unstyled?: boolean;
+};
+export declare class PopMessages extends TungstenSimpleInternalStoreComponent<Props> {
+    clientInit: () => void;
+    content: () => owned rw import("../ContentNode.js").ContentNodeClassComponent | owned rw import("../ContentNode.js").ContentNodeFragment | owned rw import("../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../ContentNode.js").ContentNodeHtml | null;
+}
+export {};
+//# sourceMappingURL=PopMessages.d.ts.map

package/dist-ti/components/Protected.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export interface ProtectedHtmlProps {
+    children: ContentNode;
+}
+export declare class Protected extends TungstenSimpleComponent<ProtectedHtmlProps> {
+    static __opaque: boolean;
+    content: () => ContentNode;
+}
+//# sourceMappingURL=Protected.d.ts.map

package/dist-ti/components/RawHtml.d.ts

@@ -0,0 +1,37 @@
+// @tightscript-object-permissions
+import type { HtmlAllowList } from '../rawHtml/HtmlAllowList.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export interface RawHtmlProps {
+    /** Markup to render. Anything unparseable is kept as text, never thrown on. */
+    html: string;
+    /**
+     * Drop `<script>` elements and `javascript:` URLs. On by default. Turn it
+     * off only for markup the application itself produced.
+     */
+    sanitize?: boolean;
+    /**
+     * Restrict the markup to a set of tags and attributes. Off by default.
+     *
+     * A disallowed element is unwrapped, not deleted, so its text survives.
+     */
+    allowList?: HtmlAllowList;
+    /**
+     * Shortcut for `allowList={safeHtmlAllowList}` — Tungsten's conservative
+     * list for authored rich text. An explicit `allowList` wins over this.
+     */
+    safe?: boolean;
+}
+/**
+ * Renders a string of HTML as real content.
+ *
+ * The markup is parsed into an ordinary Tungsten tree, so it renders, hydrates
+ * and reconciles like any other content — unlike `dangerouslySetInnerHTML`,
+ * which hands the browser a region Tungsten cannot see into.
+ *
+ * Note that the parsed elements are not part of any component's scoped CSS, so
+ * component styles reach them only through `:i()` / `:ignore()`.
+ */
+export declare class RawHtml extends TungstenSimpleComponent<RawHtmlProps> {
+    content: ({ html, sanitize, allowList, safe }: RawHtmlProps) => import("../ContentNode.js").ContentNode;
+}
+//# sourceMappingURL=RawHtml.d.ts.map

package/dist-ti/components/RouteRedirectComponent.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import type { RedirectCode } from '../routing/RedirectCode.js';
+import type { MinimumRoutes } from '../routing/Routes.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export type RouteRedirectComponentProps<Routes extends MinimumRoutes> = {
+    to: keyof Routes;
+    code?: RedirectCode;
+};
+export declare class RouteRedirectComponent<Routes extends MinimumRoutes> extends TungstenSimpleComponent<RouteRedirectComponentProps<Routes>> {
+    static __tungstenRedirect: boolean;
+    content: () => "This should redirect - if you see this, redirection didn't work" | null;
+}
+//# sourceMappingURL=RouteRedirectComponent.d.ts.map

package/dist-ti/components/Stylesheet.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import { TungstenSimpleComponent } from '../Components.jsx';
+export interface StylesheetProps {
+    children: string;
+}
+export declare class Stylesheet extends TungstenSimpleComponent<StylesheetProps> {
+    content: () => owned rw import("../ContentNode.js").ContentNodeClassComponent | owned rw import("../ContentNode.js").ContentNodeFragment | owned rw import("../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../ContentNode.js").ContentNodeHtml | null;
+}
+//# sourceMappingURL=Stylesheet.d.ts.map

package/dist-ti/components/WebRedirectComponent.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+import type { RedirectCode } from '../routing/RedirectCode.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+export type WebRedirectComponentProps = {
+    to: string;
+    code?: RedirectCode;
+};
+export declare class WebRedirectComponent extends TungstenSimpleComponent<WebRedirectComponent> {
+    static __tungstenRedirect: boolean;
+    content: () => "This should redirect - if you see this, redirection didn't work" | null;
+}
+//# sourceMappingURL=WebRedirectComponent.d.ts.map

package/dist-ti/components/_GoToComponent.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { RouteKey } from '../routing/RouteTypes.js';
+import { TungstenSimpleComponent } from '../Components.jsx';
+type Props = {
+    to: RouteKey;
+};
+export declare class GoTo extends TungstenSimpleComponent<Props> {
+    content: () => null;
+}
+export {};
+//# sourceMappingURL=_GoToComponent.d.ts.map

package/dist-ti/components/bindable/BindMode.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export type BindMode = 'direct' | 'tuple';
+//# sourceMappingURL=BindMode.d.ts.map

package/dist-ti/components/bindable/BindVariable.d.ts

@@ -0,0 +1,37 @@
+// @tightscript-object-permissions
+import type { NodeValue } from '../../ContentNode.js';
+export type BindVariable<O extends object> = [rw O, keyof O];
+export type WidestBindVariable = BindVariable<Record<PropertyKey, NodeValue>>;
+export type TypedBindVariable<O extends object, K extends keyof O> = [rw O, K];
+/**
+ * A bind, by what ends up in the bound key: `Written` has to be writable there, and nothing else
+ * is required of the object. A control with a convert writes O[K]; one without writes its own
+ * output - a string for a text input, a boolean for a checkbox, the stringified option value for
+ * a select.
+ *
+ * The permission goes on the key alone, not on O. `[readwrite O, K]` demands the WHOLE object be
+ * writable, where a bind only ever writes one key - so it turns away an object that is read-only
+ * apart from the bound key, which is precisely what permissions exist to express.
+ *
+ * Not `TypedBindVariable<O & write Record<K, Written>, K>` either: its `readwrite O` distributes
+ * over the intersection and overrides the inner `write`, demanding the key read back as `Written`
+ * too. That rejects a `string` field bound to 'a' | 'b' select options, which is sound to allow -
+ * the options are what limit the values.
+ */
+export type WritingBindVariable<O extends object, K extends keyof O, Written> = [r O & w Record<K, Written>, K];
+/**
+ * The bind of a control WITH a convert, which writes whatever the convert produces - O[K].
+ *
+ * One contract, spelled twice. `WritingBindVariable<O, K, O[K]>` is the statement we mean: the key
+ * takes an O[K], and nothing is asked of the rest of the object. `TypedBindVariable<O, K>` is
+ * strictly stronger - an object writable throughout is certainly writable at K with its own K's
+ * type - so the union admits nothing the precise form would not, and a read-only object is still
+ * turned away by both.
+ *
+ * It is there because stock TypeScript will not see that implication while O is generic: `O[K]`
+ * "could be instantiated with a different subtype of constraint", so the precise form alone rejects
+ * a generic caller passing its own bind through. Not a permissions matter - it would read the same
+ * on stock tsc. Drop the first arm if that deferral is ever resolved.
+ */
+export type ConvertedBind<O extends object, K extends keyof O> = TypedBindVariable<O, K> | WritingBindVariable<O, K, O[K]>;
+//# sourceMappingURL=BindVariable.d.ts.map

package/dist-ti/components/bindable/BindableCheckbox.d.ts

@@ -0,0 +1,26 @@
+// @tightscript-object-permissions
+import type { ConvertedBind, WritingBindVariable } from './BindVariable.js';
+import type { ConvertCheckedFunc, InputHTMLAttributes } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import type { DetailedHTMLProps } from '../../../types/jsx/jsx.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    value?: string;
+    placeholder?: string;
+};
+export type BindableCheckboxProps<O extends object, K extends keyof O> = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement, O>, HTMLInputElement>, 'bind' | 'convert' | 'bindChecked' | 'convertChecked'> & BasicProps & ({
+    convert: ConvertCheckedFunc<InputKeyboardEvent, O[K]>;
+    bindChecked?: ConvertedBind<O, K>;
+} | {
+    convert?: undefined;
+    bindChecked?: WritingBindVariable<O, K, boolean>;
+});
+export declare class BindableCheckbox<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableCheckboxProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableCheckbox.d.ts.map

package/dist-ti/components/bindable/BindableInput.d.ts

@@ -0,0 +1,22 @@
+// @tightscript-object-permissions
+import type { ConvertedBind, WritingBindVariable } from './BindVariable.js';
+import type { ConvertFuncString, InputHTMLAttributes } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import type { DetailedHTMLProps } from '../../../types/jsx/jsx.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {
+    className?: string;
+    css?: string;
+};
+type BindableInputProps<O extends object, K extends keyof O> = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement, O>, HTMLInputElement>, 'bind' | 'convert' | 'bindChecked' | 'convertChecked'> & BasicProps & ({
+    convert: ConvertFuncString<InputKeyboardEvent, O[K]>;
+    bind?: ConvertedBind<O, K>;
+} | {
+    convert?: undefined;
+    bind?: WritingBindVariable<O, K, string>;
+});
+export declare class BindableInput<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableInputProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableInput.d.ts.map

package/dist-ti/components/bindable/BindableInputNonString.d.ts

@@ -0,0 +1,23 @@
+// @tightscript-object-permissions
+import type { TypedBindVariable } from './BindVariable.js';
+import type { ConvertFuncString, HTMLInputTypeAttribute } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    type?: HTMLInputTypeAttribute | undefined;
+    value?: string;
+    placeholder?: string;
+};
+type BindableInputProps<O extends object, K extends keyof O> = BasicProps & {
+    bind?: TypedBindVariable<O, K>;
+    convert: ConvertFuncString<InputKeyboardEvent, O[K]>;
+};
+export declare class BindableInput<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableInputProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableInputNonString.d.ts.map

package/dist-ti/components/bindable/BindableInputString.d.ts

@@ -0,0 +1,23 @@
+// @tightscript-object-permissions
+import type { TypedBindVariable } from './BindVariable.js';
+import type { ConvertFuncString, HTMLInputTypeAttribute } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    type?: HTMLInputTypeAttribute | undefined;
+    value?: string;
+    placeholder?: string;
+};
+type BindableInputProps<O extends object, K extends keyof O> = BasicProps & {
+    bind?: TypedBindVariable<O, K>;
+    convert?: ConvertFuncString<InputKeyboardEvent, O[K]> | undefined;
+};
+export declare class BindableInput<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableInputProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableInputString.d.ts.map

package/dist-ti/components/bindable/BindableInputTyped.d.ts

@@ -0,0 +1,30 @@
+// @tightscript-object-permissions
+import type { ConvertFuncString, HTMLInputTypeAttribute } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type Obj = Record<string | number | symbol, unknown>;
+type KeysOfType<T, O extends Obj, K extends keyof Obj = keyof Obj> = K extends K ? (O[K] extends T ? K : never) : never;
+export type ExplicityTypedBindVariable<T, O extends Obj, K extends KeysOfType<T, O>> = [O, K];
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    type?: HTMLInputTypeAttribute | undefined;
+    value?: string;
+    placeholder?: string;
+};
+type BindableInputTypedProps<T, O extends Obj, K extends KeysOfType<T, O>> = BasicProps & ([
+    T
+] extends [string] ? {
+    bind?: ExplicityTypedBindVariable<T, O, K>;
+    convert?: ConvertFuncString<InputKeyboardEvent, O[K]> | undefined;
+} : {
+    bind?: ExplicityTypedBindVariable<T, O, K>;
+    convert: ConvertFuncString<InputKeyboardEvent, O[K]>;
+});
+export declare class BindableInputTyped<T, O extends Obj, K extends KeysOfType<T, O>> extends TungstenSimpleComponent<BindableInputTypedProps<T, O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableInputTyped.d.ts.map

package/dist-ti/components/bindable/BindableInputTypedLegacy.d.ts

@@ -0,0 +1,34 @@
+// @tightscript-object-permissions
+import type { ConvertFuncString, HTMLInputTypeAttribute } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+export type ExplicityTypedBindVariableLegacy<T, K extends string | number | symbol, O extends {
+    [Key in K]: T;
+}> = [O, K];
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    type?: HTMLInputTypeAttribute | undefined;
+    value?: string;
+    placeholder?: string;
+};
+type BindableInputTypedProps<T, K extends string | number | symbol, O extends {
+    [Key in K]: T;
+}> = BasicProps & ([
+    T
+] extends [string] ? {
+    bind?: ExplicityTypedBindVariableLegacy<T, K, O>;
+    convert?: ConvertFuncString<InputKeyboardEvent, O[K]> | undefined;
+} : {
+    bind?: ExplicityTypedBindVariableLegacy<T, K, O>;
+    convert: ConvertFuncString<InputKeyboardEvent, O[K]>;
+});
+export declare class BindableInputTypedLegacy<T, K extends string | number | symbol, O extends {
+    [Key in K]: T;
+}> extends TungstenSimpleComponent<BindableInputTypedProps<T, K, O>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableInputTypedLegacy.d.ts.map

package/dist-ti/components/bindable/BindableRadio.d.ts

@@ -0,0 +1,15 @@
+// @tightscript-object-permissions
+import type { TypedBindVariable } from './BindVariable.js';
+import type { InputHTMLAttributes } from '../../../types/jsx/html.js';
+import type { DetailedHTMLProps } from '../../../types/jsx/jsx.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {};
+export type BindableRadioProps<O extends object, K extends keyof O> = DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement, O>, HTMLInputElement> & BasicProps & {
+    value: O[K];
+    bindRadio?: TypedBindVariable<O, K>;
+};
+export declare class BindableRadio<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableRadioProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableRadio.d.ts.map

package/dist-ti/components/bindable/BindableSelect.d.ts

@@ -0,0 +1,33 @@
+// @tightscript-object-permissions
+import type { ConvertedBind, WritingBindVariable } from './BindVariable.js';
+import type { ConvertSelectFunc, HTMLInputTypeAttribute, SelectHTMLAttributes } from '../../../types/jsx/html.js';
+import type { InputKeyboardEvent } from '../../../types/jsx/html.events.js';
+import type { ContentNode } from '../../ContentNode.js';
+import type { DetailedHTMLProps } from '../../../types/jsx/jsx.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+export type OptionStruct<Value extends string | number> = {
+    value: Value;
+    text: ContentNode;
+};
+type BasicProps = {
+    className?: string;
+    style?: object;
+    css?: string;
+    name?: string;
+    type?: HTMLInputTypeAttribute | undefined;
+    value?: string;
+};
+export type BindableSelectProps<O extends object, K extends keyof O, Value extends string | number> = Omit<DetailedHTMLProps<SelectHTMLAttributes<HTMLSelectElement, O>, HTMLSelectElement>, 'bind' | 'convert'> & BasicProps & {
+    options?: readonly OptionStruct<Value>[];
+} & ({
+    convert: ConvertSelectFunc<InputKeyboardEvent, NoInfer<`${Value}`>, O[K]>;
+    bind?: ConvertedBind<O, K>;
+} | {
+    convert?: undefined;
+    bind?: WritingBindVariable<O, K, `${Value}`>;
+});
+export declare class BindableSelect<O extends object, K extends keyof O, Value extends string | number> extends TungstenSimpleComponent<BindableSelectProps<O, K, Value>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableSelect.d.ts.map

package/dist-ti/components/bindable/BindableSelectNaive.d.ts

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

package/dist-ti/components/bindable/BindableTextarea.d.ts

@@ -0,0 +1,29 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../../ContentNode.js';
+import type { ConvertedBind, WritingBindVariable } from './BindVariable.js';
+import type { ConvertFuncString, TextareaHTMLAttributes } from '../../../types/jsx/html.js';
+import type { TextareaKeyboardEvent } from '../../../types/jsx/html.events.js';
+import type { DetailedHTMLProps } from '../../../types/jsx/jsx.js';
+import { TungstenSimpleComponent } from '../../Components.jsx';
+type BasicProps = {
+    className?: string;
+    css?: string;
+    name?: string;
+    placeholder?: string;
+    rows?: number;
+    cols?: number;
+    value?: string;
+    children?: ContentNode;
+};
+type BindableTextareaProps<O extends object, K extends keyof O> = Omit<DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement, O>, HTMLTextAreaElement>, 'bind' | 'convert'> & BasicProps & ({
+    convert: ConvertFuncString<TextareaKeyboardEvent, O[K]>;
+    bind?: ConvertedBind<O, K>;
+} | {
+    convert?: undefined;
+    bind?: WritingBindVariable<O, K, string>;
+});
+export declare class BindableTextarea<O extends object, K extends keyof O> extends TungstenSimpleComponent<BindableTextareaProps<O, K>> {
+    content: () => owned rw import("../../ContentNode.js").ContentNodeClassComponent | owned rw import("../../ContentNode.js").ContentNodeFragment | owned rw import("../../ContentNode.js").ContentNodeFunctionComponent | owned rw import("../../ContentNode.js").ContentNodeHtml;
+}
+export {};
+//# sourceMappingURL=BindableTextarea.d.ts.map