@pibbl/core 0.0.1

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,35 @@
+import type { PibblElement, PibblElementType, PibblKey, PibblPrimitiveComponent, PrimitiveInputOf } from './lib/element/types.js';
+export { Fragment, jsx, jsxs } from './lib/element/jsx-runtime.js';
+/**
+ * Compiler-facing Pibbl JSX types; authored elements use the branded Pibbl element protocol.
+ *
+ * @see {@link PibblElement}
+ * @see {@link PibblElementType}
+ * @see {@link PibblKey}
+ * @see {@link PibblPrimitiveComponent}
+ * @see {@link PrimitiveInputOf}
+ */
+export declare namespace JSX {
+    /** The branded element value recognized as valid Pibbl JSX output. See {@link JSX}. */
+    type Element = PibblElement;
+    /** The synchronous component types accepted in Pibbl JSX. See {@link JSX}. */
+    type ElementType = PibblElementType;
+    /** Identifies children as the JSX child-content prop. See {@link JSX}. */
+    interface ElementChildrenAttribute {
+        /** Descendant content or the callback that supplies it. See {@link JSX}. */
+        children: unknown;
+    }
+    /** Compiler-owned JSX attributes, including stable element keys. See {@link JSX}. */
+    interface IntrinsicAttributes {
+        /** Stable identity used by the containing protocol. See {@link PibblKey}. */
+        key?: PibblKey;
+    }
+    /** Pibbl has no lowercase intrinsic JSX vocabulary. See {@link JSX}. */
+    interface IntrinsicElements {
+    }
+    /**
+     * Maps branded primitive components to their authored inputs and rejects reserved key props. See
+     * {@link JSX}.
+     */
+    type LibraryManagedAttributes<C, P> = C extends PibblPrimitiveComponent<any, any> ? PrimitiveInputOf<C> : 'key' extends keyof P ? never : P;
+}

package/dist/jsx-runtime.js

@@ -0,0 +1,7 @@
+import { Fragment, jsx, jsxs } from "./lib/element/jsx-runtime.js";
+export {
+  Fragment,
+  jsx,
+  jsxs
+};
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/jsx-runtime.ts"],
+  "sourcesContent": ["import type {\n  PibblElement,\n  PibblElementType,\n  PibblKey,\n  PibblPrimitiveComponent,\n  PrimitiveInputOf,\n} from './lib/element/types.js';\n\nexport { Fragment, jsx, jsxs } from './lib/element/jsx-runtime.js';\n\n/**\n * Compiler-facing Pibbl JSX types; authored elements use the branded Pibbl element protocol.\n *\n * @see {@link PibblElement}\n * @see {@link PibblElementType}\n * @see {@link PibblKey}\n * @see {@link PibblPrimitiveComponent}\n * @see {@link PrimitiveInputOf}\n */\nexport namespace JSX {\n  /** The branded element value recognized as valid Pibbl JSX output. See {@link JSX}. */\n  export type Element = PibblElement;\n  /** The synchronous component types accepted in Pibbl JSX. See {@link JSX}. */\n  export type ElementType = PibblElementType;\n  /** Identifies children as the JSX child-content prop. See {@link JSX}. */\n  export interface ElementChildrenAttribute {\n    /** Descendant content or the callback that supplies it. See {@link JSX}. */\n    children: unknown;\n  }\n  /** Compiler-owned JSX attributes, including stable element keys. See {@link JSX}. */\n  export interface IntrinsicAttributes {\n    /** Stable identity used by the containing protocol. See {@link PibblKey}. */\n    key?: PibblKey;\n  }\n  /** Pibbl has no lowercase intrinsic JSX vocabulary. See {@link JSX}. */\n  export interface IntrinsicElements {}\n  /**\n   * Maps branded primitive components to their authored inputs and rejects reserved key props. See\n   * {@link JSX}.\n   */\n  export type LibraryManagedAttributes<C, P> =\n    C extends PibblPrimitiveComponent<any, any>\n      ? PrimitiveInputOf<C>\n      : 'key' extends keyof P\n        ? never\n        : P;\n}\n"],
+  "mappings": "AAQA,SAAS,UAAU,KAAK,YAAY;",
+  "names": []
+}

package/dist/jsx-runtime.mjs

@@ -0,0 +1 @@
+export * from './jsx-runtime.js';

package/dist/lib/animation/definition.d.ts

@@ -0,0 +1,140 @@
+import { type SpringDefinitionRecord } from './spring.js';
+import type { PibblAnimationDefinition, PibblAnimationOptions, PibblAnimationSampleInput, PibblEasing, PibblInterpolator, PibblKeyframesOptions, PibblSpringOptions, PibblStepperOptions, PibblTweenOptions } from './types.js';
+declare const seekableDefinitionActivationBrand: unique symbol;
+interface BaseDefinitionRecord {
+    readonly duration: number;
+    readonly debugName: string | undefined;
+}
+interface TweenDefinitionRecord<T> extends BaseDefinitionRecord {
+    readonly kind: 'tween';
+    readonly hasFrom: boolean;
+    readonly from: T | undefined;
+    readonly to: T;
+    readonly easing: PibblEasing;
+    readonly interpolate: PibblInterpolator<T> | undefined;
+}
+interface KeyframesDefinitionRecord<T> extends BaseDefinitionRecord {
+    readonly kind: 'keyframes';
+    readonly values: readonly T[];
+    readonly offsets: readonly number[];
+    readonly easings: readonly PibblEasing[];
+    readonly interpolate: PibblInterpolator<T> | undefined;
+}
+interface CustomDefinitionRecord<T> extends BaseDefinitionRecord {
+    readonly kind: 'custom';
+    readonly sample: (input: PibblAnimationSampleInput<T>) => T;
+}
+export interface StepperDefinitionRecord<T> extends BaseDefinitionRecord {
+    readonly kind: 'stepper';
+    readonly stepMilliseconds: number;
+    readonly maxElapsedMilliseconds: number;
+    readonly initial: (currentValue: T) => unknown;
+    readonly step: (state: unknown, deltaMilliseconds: number) => unknown;
+    readonly read: (state: unknown) => T;
+    readonly done: ((state: unknown) => boolean) | undefined;
+}
+export type DefinitionRecord<T> = TweenDefinitionRecord<T> | KeyframesDefinitionRecord<T> | CustomDefinitionRecord<T> | StepperDefinitionRecord<T> | SpringDefinitionRecord;
+/** @internal Opaque activation-time state for one seekable track instance. */
+export interface SeekableDefinitionActivation<T> {
+    readonly [seekableDefinitionActivationBrand]: T;
+    readonly duration: number;
+    readonly initialValue: T;
+}
+/** @internal Callback-free knowledge about a seekable definition boundary. */
+export type SeekableDefinitionBoundaryValue<T> = {
+    readonly kind: 'known';
+    readonly value: T;
+} | {
+    readonly kind: 'unknown';
+};
+export interface AnimationDefinitionPerformanceSnapshot {
+    readonly keyframeDefinitions: number;
+    readonly keyframeStorageArrayAllocations: number;
+    readonly keyframeSamples: number;
+    readonly keyframeSampleArrayAllocations: number;
+}
+/** @internal Deterministic structural counters for normalized keyframe sampling. */
+export declare function animationDefinitionPerformanceSnapshot(): AnimationDefinitionPerformanceSnapshot;
+/** @internal Captures a committed output value for a playback activation. */
+export declare function snapshotAnimationActivationValue<T>(value: T, seen?: WeakMap<object, unknown>): T;
+/**
+ * Returns an opaque immutable tween definition.
+ *
+ * @param options - Start and end values, duration, easing, and interpolation settings. See
+ * {@link PibblTweenOptions} .
+ * @returns An immutable tween definition. See {@link PibblAnimationDefinition}.
+ *
+ * @see {@link PibblTweenOptions}
+ * @see {@link PibblAnimationDefinition}
+ */
+export declare function tween<T>(options: Readonly<PibblTweenOptions<T>>): PibblAnimationDefinition<T>;
+/**
+ * Returns an opaque immutable keyframe definition.
+ *
+ * @param options - Keyframe values, timing, easing, and interpolation settings. See
+ * {@link PibblKeyframesOptions} .
+ * @returns An immutable animation definition sampling the keyframes. See
+ * {@link PibblAnimationDefinition} .
+ *
+ * @see {@link PibblKeyframesOptions}
+ * @see {@link PibblAnimationDefinition}
+ */
+export declare function keyframes<T>(options: Readonly<PibblKeyframesOptions<T>>): PibblAnimationDefinition<T>;
+/**
+ * Returns an opaque immutable analytic one-dimensional spring definition.
+ *
+ * @param options - Target, initial conditions, and spring parameters. See {@link PibblSpringOptions}
+ * .
+ * @returns An analytic numeric spring definition. See {@link PibblAnimationDefinition}.
+ *
+ * @see {@link PibblSpringOptions}
+ * @see {@link PibblAnimationDefinition}
+ */
+export declare function spring(options: Readonly<PibblSpringOptions>): PibblAnimationDefinition<number>;
+/**
+ * Returns an opaque immutable definition from a custom seekable sampler.
+ *
+ * @param options - Duration and pure sampling callback for the animation. See
+ * {@link PibblAnimationOptions} .
+ * @returns An immutable, seekable animation definition. See {@link PibblAnimationDefinition}.
+ *
+ * @see {@link PibblAnimationOptions}
+ * @see {@link PibblAnimationDefinition}
+ */
+export declare function defineAnimation<T>(options: Readonly<PibblAnimationOptions<T>>): PibblAnimationDefinition<T>;
+/**
+ * Returns an opaque immutable stepper definition. Steppers are evaluated by
+ * the playback engine, not by the seekable sampler.
+ *
+ * @param options - Initial state, fixed-step integration, value reader, and completion predicate.
+ * See {@link PibblStepperOptions} .
+ * @returns A stateful animation definition advanced by fixed simulation steps. See
+ * {@link PibblAnimationDefinition} .
+ *
+ * @see {@link PibblStepperOptions}
+ * @see {@link PibblAnimationDefinition}
+ */
+export declare function stepper<State, T>(options: Readonly<PibblStepperOptions<State, T>>): PibblAnimationDefinition<T>;
+/** @internal Returns the private immutable record associated with a definition. */
+export declare function getDefinitionRecord<T>(definition: PibblAnimationDefinition<T>): DefinitionRecord<T>;
+/** @internal Samples a non-stepper definition from its activation snapshot. */
+export declare function sampleSeekableDefinition<T>(definition: PibblAnimationDefinition<T>, input: Readonly<Pick<PibblAnimationSampleInput<T>, 'initialValue' | 'localTime'>>): T;
+/**
+ * @internal Resolves activation-dependent definition data exactly once for a
+ * track instance. Stateful definitions use a separate playback-owned record.
+ */
+export declare function activateSeekableDefinition<T>(definition: PibblAnimationDefinition<T>, initialValue: T, seen?: WeakMap<object, unknown>): SeekableDefinitionActivation<T>;
+/** @internal Samples a definition from one retained activation record. */
+export declare function sampleActivatedSeekableDefinition<T>(activation: SeekableDefinitionActivation<T>, localTime: number): T;
+/**
+ * @internal Returns a boundary value only when the normalized definition makes
+ * it exact without invoking user easing, interpolation, or sampling callbacks.
+ */
+export declare function getSeekableDefinitionBoundaryValue<T>(activation: SeekableDefinitionActivation<T>, boundary: 'start' | 'end'): SeekableDefinitionBoundaryValue<T>;
+/**
+ * @internal Returns a callback-free boundary that does not depend on a track's
+ * activation value. This lets discovery recover known terminal state after an
+ * earlier opaque custom value.
+ */
+export declare function getStaticSeekableDefinitionBoundaryValue<T>(definition: PibblAnimationDefinition<T>, boundary: 'start' | 'end'): SeekableDefinitionBoundaryValue<T>;
+export {};