@b9g/crank 0.7.4 → 0.7.6

package/_css.d.ts

@@ -1,21 +0,0 @@
-/**
- * CSS utility functions for style property transformation.
- *
- * This module handles camelCase to kebab-case conversion and automatic
- * px unit conversion for numeric CSS values, making Crank more React-compatible.
- */
-/**
- * Converts camelCase CSS property names to kebab-case.
- * Handles vendor prefixes correctly (WebkitTransform -> -webkit-transform).
- */
-export declare function camelToKebabCase(str: string): string;
-/**
- * CSS properties that should remain unitless when given numeric values.
- * Based on React's list of unitless properties.
- */
-export declare const UNITLESS_PROPERTIES: Set<string>;
-/**
- * Formats CSS property values, automatically adding "px" to numeric values
- * for properties that are not unitless.
- */
-export declare function formatStyleValue(name: string, value: unknown): string;

package/_utils.d.ts

@@ -1,14 +0,0 @@
-export declare function wrap<T>(value: Array<T> | T | undefined): Array<T>;
-export declare function unwrap<T>(arr: Array<T>): Array<T> | T | undefined;
-export type NonStringIterable<T> = Iterable<T> & object;
-/**
- * Ensures a value is an array.
- *
- * This function does the same thing as wrap() above except it handles nulls
- * and iterables, so it is appropriate for wrapping user-provided element
- * children.
- */
-export declare function arrayify<T>(value: NonStringIterable<T> | T | null | undefined): Array<T>;
-export declare function isIteratorLike(value: any): value is Iterator<unknown> | AsyncIterator<unknown>;
-export declare function isPromiseLike(value: any): value is PromiseLike<unknown>;
-export declare function safeRace<T>(contenders: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;

package/async.d.ts

@@ -1,107 +0,0 @@
-import type { Children, Component, Context } from "./crank.js";
-/**
- * Creates a lazy-loaded component from an initializer function.
- *
- * @param initializer - Function that returns a Promise resolving to a component or module
- * @returns A component that loads the target component on first render
- *
- * @example
- * ```jsx
- * const LazyComponent = lazy(() => import('./MyComponent'));
- *
- * <Suspense fallback={<div>Loading...</div>}>
- *   <LazyComponent prop="value" />
- * </Suspense>
- * ```
- */
-export declare function lazy<T extends Component>(initializer: () => Promise<T | {
-    default: T;
-}>): T;
-/**
- * A component that displays a fallback while its children are loading.
- *
- * When used within a SuspenseList, coordinates with siblings to control
- * reveal order and fallback behavior.
- *
- * @param children - The content to display when loading is complete
- * @param fallback - The content to display while children are loading
- * @param timeout - Time in milliseconds before showing fallback (defaults to
- * 300ms standalone, or inherits from SuspenseList)
- *
- * @example
- * ```jsx
- * <Suspense fallback={<div>Loading...</div>}>
- *   <AsyncComponent />
- * </Suspense>
- * ```
- */
-export declare function Suspense(this: Context, { children, fallback, timeout, }: {
-    children: Children;
-    fallback: Children;
-    timeout?: number;
-}): AsyncGenerator<Children>;
-declare const SuspenseListController: unique symbol;
-interface SuspenseListItem {
-    ctx: Context;
-    resolve: () => void;
-    promise: Promise<void>;
-}
-interface SuspenseListController {
-    timeout?: number;
-    revealOrder?: "forwards" | "backwards" | "together";
-    tail?: "collapsed" | "hidden";
-    register(ctx: Context): Promise<Array<SuspenseListItem>>;
-    isHead(ctx: Context, items: Array<SuspenseListItem>): boolean;
-    scheduleFallback(ctx: Context, items: Array<SuspenseListItem>): Promise<void>;
-    scheduleChildren(ctx: Context, items: Array<SuspenseListItem>): Promise<void>;
-}
-declare global {
-    namespace Crank {
-        interface ProvisionMap {
-            [SuspenseListController]: SuspenseListController;
-        }
-    }
-}
-/**
- * Controls when child <Suspense> components show their content or fallbacks
- * based on the specified reveal order. The <SuspenseList> resolves when
- * coordination effort is complete (not necessarily when all content is
- * loaded).
- *
- * @param revealOrder - How children should be revealed:
- *   - "forwards" (default): Show children in document order, waiting for
- *     predecessors
- *   - "backwards": Show children in reverse order, waiting for successors
- *   - "together": Show all children simultaneously when all are ready
- *   In Crank, the default behavior of async components is to render together,
- *   so "together" might not be necessary if you are not using <Suspense>
- *   fallbacks.
- *e@param tail - How to handle fallbacks:
- *   - "collapsed" (default): Show only the fallback for the next unresolved
- *     Suspense component
- *   - "hidden": Hide all fallbacks
- *   Tail behavior only applies when revealOrder is not "together".
- * @param timeout - Default timeout for Suspense children in milliseconds
- * @param children - The elements containing Suspense components to coordinate.
- *   Suspense components which are not rendered immediately (because they are
- *   the children of another async component) will not be coordinated.
- *
- * @example
- * ```jsx
- * <SuspenseList revealOrder="forwards" tail="collapsed">
- *   <Suspense fallback={<div>Loading A...</div>}>
- *     <ComponentA />
- *   </Suspense>
- *   <Suspense fallback={<div>Loading B...</div>}>
- *     <ComponentB />
- *   </Suspense>
- * </SuspenseList>
- * ```
- */
-export declare function SuspenseList(this: Context, { revealOrder, tail, timeout, children, }: {
-    revealOrder?: "forwards" | "backwards" | "together";
-    tail?: "collapsed" | "hidden";
-    timeout?: number;
-    children: Children;
-}): Generator<Children>;
-export {};