@hyperfixi/core 3.1.1 → 3.2.0

package/dist/chunks/index-uCOQ8Qn0.js

@@ -0,0 +1,2 @@
+let t=null;async function n(){if(!t)try{t=await(import("./index-DQi2o8Lk.js"))}catch{throw Error("@lokascript/framework is required for LSE support. Install it: npm install @lokascript/framework")}return t}function r(){if(t)return!0;try{return require.resolve("@lokascript/framework"),!0}catch{return!1}}async function a(t,r){return(await n()).parseExplicit(t,r)}async function i(t){return(await n()).isExplicitSyntax(t)}async function o(t){return(await n()).renderExplicit(t)}async function e(t){return(await n()).fromInterchangeNode(t)}async function c(t){return(await n()).toProtocolJSON(t)}async function u(t){return(await n()).fromProtocolJSON(t)}async function s(t){return(await n()).validateProtocolJSON(t)}async function f(t){return(await n()).toEnvelopeJSON(t)}async function l(t){return(await n()).fromEnvelopeJSON(t)}async function w(t){return(await n()).isEnvelope(t)}async function p(t){return(await n()).semanticNodeToRuntimeAST(t)}export{l as fromEnvelopeJSON,e as fromInterchangeNode,u as fromProtocolJSON,w as isEnvelope,i as isExplicitSyntax,r as isLSEAvailable,a as parseExplicit,o as renderExplicit,p as semanticNodeToRuntimeAST,f as toEnvelopeJSON,c as toProtocolJSON,s as validateProtocolJSON};
+//# sourceMappingURL=index-uCOQ8Qn0.js.map

package/dist/commands/animation/transition.d.ts

@@ -2,12 +2,17 @@ import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
 import type { ExpressionEvaluator } from '../../core/expression-evaluator';
 import { type DecoratedCommand } from '../decorators';
 import type { CommandRaw } from '../../ast/command-slots';
-export interface TransitionCommandInput {
-    target?: string | HTMLElement;
+export interface TransitionPairInput {
+    target?: string | HTMLElement | HTMLElement[];
     property: string;
     value: string | number;
+    from?: string | number;
+}
+export interface TransitionCommandInput extends TransitionPairInput {
     duration?: number | string;
     timingFunction?: string;
+    using?: string;
+    pairs?: TransitionPairInput[];
 }
 export interface TransitionCommandOutput {
     element: HTMLElement;
@@ -20,22 +25,23 @@ export interface TransitionCommandOutput {
 export declare class TransitionCommand implements DecoratedCommand {
     static readonly metadata: {
         readonly description: "Animate CSS properties using CSS transitions";
-        readonly syntax: "transition [<target>] <property> to <value> [over <duration>] [with <timing>]";
-        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out"];
+        readonly syntax: "transition <property> [from <value>] to <value> [<property> … to <value>]… [over <duration>] [using <css> | with <timing>]";
+        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out", "transition *width to 100px *height to 50px over 300ms", "transition *opacity of #panel from 0 to 1 over 200ms", "transition my *opacity to 0 using \"opacity 1s ease-in\""];
         readonly sideEffects: readonly ["style-change", "timing"];
         readonly category: "animation";
         readonly compatibility: "standard";
     };
     get metadata(): {
         readonly description: "Animate CSS properties using CSS transitions";
-        readonly syntax: "transition [<target>] <property> to <value> [over <duration>] [with <timing>]";
-        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out"];
+        readonly syntax: "transition <property> [from <value>] to <value> [<property> … to <value>]… [over <duration>] [using <css> | with <timing>]";
+        readonly examples: readonly ["transition opacity to 0.5", "transition my *opacity to 0 over 200ms", "transition #box's *opacity to 0 over 200ms", "transition left to 100px over 500ms", "transition background-color to red over 1s with ease-in-out", "transition *width to 100px *height to 50px over 300ms", "transition *opacity of #panel from 0 to 1 over 200ms", "transition my *opacity to 0 using \"opacity 1s ease-in\""];
         readonly sideEffects: readonly ["style-change", "timing"];
         readonly category: "animation";
         readonly compatibility: "standard";
     };
     readonly name: string;
     parseInput(raw: CommandRaw<'transition'>, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<TransitionCommandInput>;
+    private laterPairs;
     execute(input: TransitionCommandInput, context: TypedExecutionContext): Promise<TransitionCommandOutput>;
 }
 export declare const createTransitionCommand: () => TransitionCommand;

package/dist/commands/helpers/loop-executor.d.ts

@@ -37,11 +37,11 @@ export declare function createTimesLoopConfig(count: number, indexVariable?: str
     config: LoopConfig;
     iterCtx: LoopIterationContext;
 };
-export declare function createWhileLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean, context: TypedExecutionContext, indexVariable?: string): {
+export declare function createWhileLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
     config: LoopConfig;
     iterCtx: LoopIterationContext;
 };
-export declare function createUntilLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean, context: TypedExecutionContext, indexVariable?: string): {
+export declare function createUntilLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
     config: LoopConfig;
     iterCtx: LoopIterationContext;
 };

package/dist/commands/helpers/numeric-target-parser.d.ts

@@ -11,7 +11,7 @@ export interface NumericCustomWrite {
     currentValue: number;
 }
 export interface NumericTargetInput {
-    target: string | HTMLElement | number;
+    target: string | HTMLElement | number | Record<string, unknown>;
     property?: string;
     scope?: 'global' | 'local';
     amount: number;

package/dist/commands/helpers/variable-access.d.ts

@@ -1,10 +1,13 @@
 import type { ExecutionContext } from '../../types/base-types';
 export declare function convertToNumber(value: unknown): number;
+export declare function counterAmount(value: unknown): number;
+export declare function counterValue(value: unknown): number;
 export declare function getVariableValue(name: string, context: ExecutionContext, preferredScope?: string): unknown;
 export declare function setVariableValue(name: string, value: unknown, context: ExecutionContext, preferredScope?: string): void;
 export declare function resolveElementRef(elementRef: string, context: ExecutionContext): unknown;
 export declare function getElementPropertyValue(propertyPath: string, context: ExecutionContext): number;
 export declare function setElementPropertyValue(propertyPath: string, value: unknown, context: ExecutionContext): void;
-export declare function getCurrentNumericValue(target: string | HTMLElement | number, property: string | undefined, scope: string | undefined, context: ExecutionContext): number;
-export declare function setTargetValue(target: string | HTMLElement | number, property: string | undefined, scope: string | undefined, newValue: unknown, context: ExecutionContext): void;
+export declare function isObjectOwner(value: unknown): value is Record<string, unknown>;
+export declare function getCurrentNumericValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, context: ExecutionContext): number;
+export declare function setTargetValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, newValue: unknown, context: ExecutionContext): void;
 //# sourceMappingURL=variable-access.d.ts.map

package/dist/commands/helpers/write-target.d.ts

@@ -21,6 +21,10 @@ export type WriteTarget = {
 } | {
     kind: 'property';
     target: PropertyTarget;
+} | {
+    kind: 'member';
+    container: Record<string, unknown>;
+    property: string;
 } | {
     kind: 'variable';
     name: string;
@@ -31,6 +35,7 @@ export interface WriteTargetOptions {
     nodeWriters?: boolean;
     selectorSource?: boolean;
     styleSplit?: boolean;
+    ofAndObjectProperty?: boolean;
     bareReference?: boolean;
 }
 export declare function resolveWriteTarget(node: ASTNode | Record<string, unknown> | undefined, evaluator: ExpressionEvaluator, context: ExecutionContext, options: WriteTargetOptions): Promise<WriteTarget | null>;