@dcl/asset-packs 1.2.1 → 1.2.2-20231010134915.commit-6abb6ed

package/dist/definitions.js

@@ -0,0 +1,205 @@
+import { Schemas, } from '@dcl/sdk/ecs';
+import { addActionType } from './action-types';
+export * from './action-types';
+export * from './events';
+export * from './id';
+export * from './states';
+export var ComponentName;
+(function (ComponentName) {
+    ComponentName["ACTION_TYPES"] = "asset-packs::ActionTypes";
+    ComponentName["ACTIONS"] = "asset-packs::Actions";
+    ComponentName["COUNTER"] = "asset-packs::Counter";
+    ComponentName["TRIGGERS"] = "asset-packs::Triggers";
+    ComponentName["STATES"] = "asset-packs::States";
+})(ComponentName || (ComponentName = {}));
+export var TweenType;
+(function (TweenType) {
+    TweenType["MOVE_ITEM"] = "move_item";
+    TweenType["ROTATE_ITEM"] = "rotate_item";
+    TweenType["SCALE_ITEM"] = "scale_item";
+})(TweenType || (TweenType = {}));
+export var InterpolationType;
+(function (InterpolationType) {
+    InterpolationType["LINEAR"] = "linear";
+    InterpolationType["EASEINQUAD"] = "easeinquad";
+    InterpolationType["EASEOUTQUAD"] = "easeoutquad";
+    InterpolationType["EASEQUAD"] = "easequad";
+    InterpolationType["EASEINSINE"] = "easeinsine";
+    InterpolationType["EASEOUTSINE"] = "easeoutsine";
+    InterpolationType["EASESINE"] = "easeinoutsine";
+    InterpolationType["EASEINEXPO"] = "easeinexpo";
+    InterpolationType["EASEOUTEXPO"] = "easeoutexpo";
+    InterpolationType["EASEEXPO"] = "easeinoutexpo";
+    InterpolationType["EASEINELASTIC"] = "easeinelastic";
+    InterpolationType["EASEOUTELASTIC"] = "easeoutelastic";
+    InterpolationType["EASEELASTIC"] = "easeinoutelastic";
+    InterpolationType["EASEINBOUNCE"] = "easeinbounce";
+    InterpolationType["EASEOUTEBOUNCE"] = "easeoutbounce";
+    InterpolationType["EASEBOUNCE"] = "easeinoutbounce";
+})(InterpolationType || (InterpolationType = {}));
+export var ActionType;
+(function (ActionType) {
+    ActionType["PLAY_ANIMATION"] = "play_animation";
+    ActionType["STOP_ANIMATION"] = "stop_animation";
+    ActionType["SET_STATE"] = "set_state";
+    ActionType["START_TWEEN"] = "start_tween";
+    ActionType["SET_COUNTER"] = "set_counter";
+    ActionType["INCREMENT_COUNTER"] = "increment_counter";
+    ActionType["DECREASE_COUNTER"] = "decrease_counter";
+    ActionType["PLAY_SOUND"] = "play_sound";
+    ActionType["STOP_SOUND"] = "stop_sound";
+    ActionType["SET_VISIBILITY"] = "set_visibility";
+    ActionType["ATTACH_TO_PLAYER"] = "attach_to_player";
+    ActionType["DETACH_FROM_PLAYER"] = "detach_from_player";
+})(ActionType || (ActionType = {}));
+export const ActionSchemas = {
+    [ActionType.PLAY_ANIMATION]: Schemas.Map({
+        animation: Schemas.String,
+        loop: Schemas.Optional(Schemas.Boolean),
+    }),
+    [ActionType.STOP_ANIMATION]: Schemas.Map({}),
+    [ActionType.SET_STATE]: Schemas.Map({ state: Schemas.String }),
+    [ActionType.START_TWEEN]: Schemas.Map({
+        type: Schemas.EnumString(TweenType, TweenType.MOVE_ITEM),
+        end: Schemas.Vector3,
+        interpolationType: Schemas.EnumString(InterpolationType, InterpolationType.LINEAR),
+        duration: Schemas.Float,
+        relative: Schemas.Boolean,
+    }),
+    [ActionType.SET_COUNTER]: Schemas.Map({ counter: Schemas.Int }),
+    [ActionType.INCREMENT_COUNTER]: Schemas.Map({}),
+    [ActionType.DECREASE_COUNTER]: Schemas.Map({}),
+    [ActionType.PLAY_SOUND]: Schemas.Map({
+        src: Schemas.String,
+        loop: Schemas.Optional(Schemas.Boolean),
+        volume: Schemas.Optional(Schemas.Float),
+    }),
+    [ActionType.STOP_SOUND]: Schemas.Map({}),
+    [ActionType.SET_VISIBILITY]: Schemas.Map({
+        visible: Schemas.Boolean,
+        physicsCollider: Schemas.Optional(Schemas.Boolean),
+    }),
+    [ActionType.ATTACH_TO_PLAYER]: Schemas.Map({
+        anchorPointId: Schemas.Int,
+    }),
+    [ActionType.DETACH_FROM_PLAYER]: Schemas.Map({}),
+};
+export var TriggerType;
+(function (TriggerType) {
+    TriggerType["ON_CLICK"] = "on_click";
+    TriggerType["ON_STATE_CHANGE"] = "on_state_change";
+    TriggerType["ON_SPAWN"] = "on_spawn";
+    TriggerType["ON_TWEEN_END"] = "on_tween_end";
+    TriggerType["ON_COUNTER_CHANGE"] = "on_counter_change";
+    TriggerType["ON_PLAYER_ENTERS_AREA"] = "on_player_enters_area";
+    TriggerType["ON_PLAYER_LEAVES_AREA"] = "on_player_leaves_area";
+})(TriggerType || (TriggerType = {}));
+export var TriggerConditionType;
+(function (TriggerConditionType) {
+    TriggerConditionType["WHEN_STATE_IS"] = "when_state_is";
+    TriggerConditionType["WHEN_STATE_IS_NOT"] = "when_state_is_not";
+    TriggerConditionType["WHEN_COUNTER_EQUALS"] = "when_counter_equals";
+    TriggerConditionType["WHEN_COUNTER_IS_GREATER_THAN"] = "when_counter_is_greater_than";
+    TriggerConditionType["WHEN_COUNTER_IS_LESS_THAN"] = "when_counter_is_less_than";
+})(TriggerConditionType || (TriggerConditionType = {}));
+export var TriggerConditionOperation;
+(function (TriggerConditionOperation) {
+    TriggerConditionOperation["AND"] = "and";
+    TriggerConditionOperation["OR"] = "or";
+})(TriggerConditionOperation || (TriggerConditionOperation = {}));
+export function getComponent(componentName, engine) {
+    try {
+        return engine.getComponent(componentName);
+    }
+    catch (error) {
+        console.error(`Error using getComponent with componentName="${componentName}"`);
+        throw error;
+    }
+}
+export function getComponents(engine) {
+    return {
+        Actions: getComponent(ComponentName.ACTIONS, engine),
+        States: getComponent(ComponentName.STATES, engine),
+        Counter: getComponent(ComponentName.COUNTER, engine),
+        Triggers: getComponent(ComponentName.TRIGGERS, engine),
+    };
+}
+export function createComponents(engine) {
+    const ActionTypes = engine.defineComponent(ComponentName.ACTION_TYPES, {
+        value: Schemas.Array(Schemas.Map({
+            type: Schemas.String,
+            jsonSchema: Schemas.String,
+        })),
+    });
+    const Actions = engine.defineComponent(ComponentName.ACTIONS, {
+        id: Schemas.Int,
+        value: Schemas.Array(Schemas.Map({
+            name: Schemas.String,
+            type: Schemas.String,
+            jsonPayload: Schemas.String,
+        })),
+    });
+    const Counter = engine.defineComponent(ComponentName.COUNTER, {
+        id: Schemas.Number,
+        value: Schemas.Int,
+    });
+    const Triggers = engine.defineComponent(ComponentName.TRIGGERS, {
+        value: Schemas.Array(Schemas.Map({
+            type: Schemas.EnumString(TriggerType, TriggerType.ON_CLICK),
+            conditions: Schemas.Optional(Schemas.Array(Schemas.Map({
+                id: Schemas.Optional(Schemas.Int),
+                type: Schemas.EnumString(TriggerConditionType, TriggerConditionType.WHEN_STATE_IS),
+                value: Schemas.String,
+            }))),
+            operation: Schemas.Optional(Schemas.EnumString(TriggerConditionOperation, TriggerConditionOperation.AND)),
+            actions: Schemas.Array(Schemas.Map({
+                id: Schemas.Optional(Schemas.Int),
+                name: Schemas.Optional(Schemas.String),
+            })),
+        })),
+    });
+    const States = engine.defineComponent(ComponentName.STATES, {
+        id: Schemas.Number,
+        value: Schemas.Array(Schemas.String),
+        defaultValue: Schemas.Optional(Schemas.String),
+        currentValue: Schemas.Optional(Schemas.String),
+    });
+    return {
+        ActionTypes,
+        Actions,
+        Counter,
+        Triggers,
+        States,
+    };
+}
+export function initComponents(engine) {
+    const actionTypes = Object.values(ActionType);
+    for (const type of actionTypes) {
+        const actionType = type;
+        addActionType(engine, actionType, ActionSchemas[actionType]);
+    }
+    const Counter = engine.getComponent(ComponentName.COUNTER);
+    const counter = Counter.getOrCreateMutable(engine.RootEntity);
+    counter.value = counter.value || 0;
+}
+export function getConditionTypesByComponentName(componentName) {
+    switch (componentName) {
+        case ComponentName.STATES: {
+            return [
+                TriggerConditionType.WHEN_STATE_IS,
+                TriggerConditionType.WHEN_STATE_IS_NOT,
+            ];
+        }
+        case ComponentName.COUNTER: {
+            return [
+                TriggerConditionType.WHEN_COUNTER_EQUALS,
+                TriggerConditionType.WHEN_COUNTER_IS_GREATER_THAN,
+                TriggerConditionType.WHEN_COUNTER_IS_LESS_THAN,
+            ];
+        }
+        default: {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IEngine,\n  ISchema,\n  LastWriteWinElementSetComponentDefinition,\n  Schemas,\n} from '@dcl/sdk/ecs'\nimport { addActionType } from './action-types'\n\nexport * from './action-types'\nexport * from './events'\nexport * from './id'\nexport * from './states'\n\nexport enum ComponentName {\n  ACTION_TYPES = 'asset-packs::ActionTypes',\n  ACTIONS = 'asset-packs::Actions',\n  COUNTER = 'asset-packs::Counter',\n  TRIGGERS = 'asset-packs::Triggers',\n  STATES = 'asset-packs::States',\n}\n\nexport enum TweenType {\n  MOVE_ITEM = 'move_item',\n  ROTATE_ITEM = 'rotate_item',\n  SCALE_ITEM = 'scale_item',\n}\n\nexport enum InterpolationType {\n  LINEAR = 'linear',\n  EASEINQUAD = 'easeinquad',\n  EASEOUTQUAD = 'easeoutquad',\n  EASEQUAD = 'easequad',\n  EASEINSINE = 'easeinsine',\n  EASEOUTSINE = 'easeoutsine',\n  EASESINE = 'easeinoutsine',\n  EASEINEXPO = 'easeinexpo',\n  EASEOUTEXPO = 'easeoutexpo',\n  EASEEXPO = 'easeinoutexpo',\n  EASEINELASTIC = 'easeinelastic',\n  EASEOUTELASTIC = 'easeoutelastic',\n  EASEELASTIC = 'easeinoutelastic',\n  EASEINBOUNCE = 'easeinbounce',\n  EASEOUTEBOUNCE = 'easeoutbounce',\n  EASEBOUNCE = 'easeinoutbounce',\n}\n\nexport enum ActionType {\n  PLAY_ANIMATION = 'play_animation',\n  STOP_ANIMATION = 'stop_animation',\n  SET_STATE = 'set_state',\n  START_TWEEN = 'start_tween',\n  SET_COUNTER = 'set_counter',\n  INCREMENT_COUNTER = 'increment_counter',\n  DECREASE_COUNTER = 'decrease_counter',\n  PLAY_SOUND = 'play_sound',\n  STOP_SOUND = 'stop_sound',\n  SET_VISIBILITY = 'set_visibility',\n  ATTACH_TO_PLAYER = 'attach_to_player',\n  DETACH_FROM_PLAYER = 'detach_from_player',\n}\n\nexport const ActionSchemas = {\n  [ActionType.PLAY_ANIMATION]: Schemas.Map({\n    animation: Schemas.String,\n    loop: Schemas.Optional(Schemas.Boolean),\n  }),\n  [ActionType.STOP_ANIMATION]: Schemas.Map({}),\n  [ActionType.SET_STATE]: Schemas.Map({ state: Schemas.String }),\n  [ActionType.START_TWEEN]: Schemas.Map({\n    type: Schemas.EnumString<TweenType>(TweenType, TweenType.MOVE_ITEM),\n    end: Schemas.Vector3,\n    interpolationType: Schemas.EnumString(\n      InterpolationType,\n      InterpolationType.LINEAR,\n    ),\n    duration: Schemas.Float,\n    relative: Schemas.Boolean,\n  }),\n  [ActionType.SET_COUNTER]: Schemas.Map({ counter: Schemas.Int }),\n  [ActionType.INCREMENT_COUNTER]: Schemas.Map({}),\n  [ActionType.DECREASE_COUNTER]: Schemas.Map({}),\n  [ActionType.PLAY_SOUND]: Schemas.Map({\n    src: Schemas.String,\n    loop: Schemas.Optional(Schemas.Boolean),\n    volume: Schemas.Optional(Schemas.Float),\n  }),\n  [ActionType.STOP_SOUND]: Schemas.Map({}),\n  [ActionType.SET_VISIBILITY]: Schemas.Map({\n    visible: Schemas.Boolean,\n    physicsCollider: Schemas.Optional(Schemas.Boolean),\n  }),\n  [ActionType.ATTACH_TO_PLAYER]: Schemas.Map({\n    anchorPointId: Schemas.Int,\n  }),\n  [ActionType.DETACH_FROM_PLAYER]: Schemas.Map({}),\n}\n\nexport type ActionPayload<T extends ActionType = any> =\n  T extends keyof typeof ActionSchemas\n    ? (typeof ActionSchemas)[T] extends ISchema\n      ? ReturnType<(typeof ActionSchemas)[T]['deserialize']>\n      : {}\n    : {}\n\nexport enum TriggerType {\n  ON_CLICK = 'on_click',\n  ON_STATE_CHANGE = 'on_state_change',\n  ON_SPAWN = 'on_spawn',\n  ON_TWEEN_END = 'on_tween_end',\n  ON_COUNTER_CHANGE = 'on_counter_change',\n  ON_PLAYER_ENTERS_AREA = 'on_player_enters_area',\n  ON_PLAYER_LEAVES_AREA = 'on_player_leaves_area',\n}\n\nexport enum TriggerConditionType {\n  WHEN_STATE_IS = 'when_state_is',\n  WHEN_STATE_IS_NOT = 'when_state_is_not',\n  WHEN_COUNTER_EQUALS = 'when_counter_equals',\n  WHEN_COUNTER_IS_GREATER_THAN = 'when_counter_is_greater_than',\n  WHEN_COUNTER_IS_LESS_THAN = 'when_counter_is_less_than',\n}\n\nexport enum TriggerConditionOperation {\n  AND = 'and',\n  OR = 'or',\n}\n\nexport function getComponent<T>(componentName: string, engine: IEngine) {\n  try {\n    return engine.getComponent(\n      componentName,\n    ) as LastWriteWinElementSetComponentDefinition<T>\n  } catch (error) {\n    console.error(\n      `Error using getComponent with componentName=\"${componentName}\"`,\n    )\n    throw error\n  }\n}\n\nexport function getComponents(engine: IEngine) {\n  return {\n    Actions: getComponent<Actions>(ComponentName.ACTIONS, engine),\n    States: getComponent<States>(ComponentName.STATES, engine),\n    Counter: getComponent<Counter>(ComponentName.COUNTER, engine),\n    Triggers: getComponent<Triggers>(ComponentName.TRIGGERS, engine),\n  }\n}\n\nexport function createComponents(engine: IEngine) {\n  const ActionTypes = engine.defineComponent(ComponentName.ACTION_TYPES, {\n    value: Schemas.Array(\n      Schemas.Map({\n        type: Schemas.String,\n        jsonSchema: Schemas.String,\n      }),\n    ),\n  })\n\n  const Actions = engine.defineComponent(ComponentName.ACTIONS, {\n    id: Schemas.Int,\n    value: Schemas.Array(\n      Schemas.Map({\n        name: Schemas.String,\n        type: Schemas.String,\n        jsonPayload: Schemas.String,\n      }),\n    ),\n  })\n\n  const Counter = engine.defineComponent(ComponentName.COUNTER, {\n    id: Schemas.Number,\n    value: Schemas.Int,\n  })\n\n  const Triggers = engine.defineComponent(ComponentName.TRIGGERS, {\n    value: Schemas.Array(\n      Schemas.Map({\n        type: Schemas.EnumString<TriggerType>(\n          TriggerType,\n          TriggerType.ON_CLICK,\n        ),\n        conditions: Schemas.Optional(\n          Schemas.Array(\n            Schemas.Map({\n              id: Schemas.Optional(Schemas.Int),\n              type: Schemas.EnumString<TriggerConditionType>(\n                TriggerConditionType,\n                TriggerConditionType.WHEN_STATE_IS,\n              ),\n              value: Schemas.String,\n            }),\n          ),\n        ),\n        operation: Schemas.Optional(\n          Schemas.EnumString<TriggerConditionOperation>(\n            TriggerConditionOperation,\n            TriggerConditionOperation.AND,\n          ),\n        ),\n        actions: Schemas.Array(\n          Schemas.Map({\n            id: Schemas.Optional(Schemas.Int),\n            name: Schemas.Optional(Schemas.String),\n          }),\n        ),\n      }),\n    ),\n  })\n\n  const States = engine.defineComponent(ComponentName.STATES, {\n    id: Schemas.Number,\n    value: Schemas.Array(Schemas.String),\n    defaultValue: Schemas.Optional(Schemas.String),\n    currentValue: Schemas.Optional(Schemas.String),\n  })\n\n  return {\n    ActionTypes,\n    Actions,\n    Counter,\n    Triggers,\n    States,\n  }\n}\n\nexport function initComponents(engine: IEngine) {\n  // Add actions from this package\n  const actionTypes = Object.values(ActionType)\n  for (const type of actionTypes) {\n    const actionType = type as ActionType\n    addActionType(engine, actionType, ActionSchemas[actionType])\n  }\n\n  // Add counter to root entity\n  const Counter = engine.getComponent(\n    ComponentName.COUNTER,\n  ) as LastWriteWinElementSetComponentDefinition<Counter>\n  const counter = Counter.getOrCreateMutable(engine.RootEntity)\n  counter.value = counter.value || 0\n}\n\nexport function getConditionTypesByComponentName(componentName: ComponentName) {\n  switch (componentName) {\n    case ComponentName.STATES: {\n      return [\n        TriggerConditionType.WHEN_STATE_IS,\n        TriggerConditionType.WHEN_STATE_IS_NOT,\n      ]\n    }\n    case ComponentName.COUNTER: {\n      return [\n        TriggerConditionType.WHEN_COUNTER_EQUALS,\n        TriggerConditionType.WHEN_COUNTER_IS_GREATER_THAN,\n        TriggerConditionType.WHEN_COUNTER_IS_LESS_THAN,\n      ]\n    }\n    default: {\n      return []\n    }\n  }\n}\n\nexport type Components = ReturnType<typeof createComponents>\n\nexport type ActionTypesComponent = Components['ActionTypes']\nexport type ActionTypes = ReturnType<\n  ActionTypesComponent['schema']['deserialize']\n>\n\nexport type ActionsComponent = Components['Actions']\nexport type Actions = ReturnType<ActionsComponent['schema']['deserialize']>\nexport type Action = Actions['value'][0]\n\nexport type CounterComponent = Components['Counter']\nexport type Counter = ReturnType<CounterComponent['schema']['deserialize']>\n\nexport type TriggersComponent = Components['Triggers']\nexport type Triggers = ReturnType<TriggersComponent['schema']['deserialize']>\nexport type Trigger = Triggers['value'][0]\nexport type TriggerAction = Trigger['actions'][0]\nexport type TriggerCondition = Exclude<Trigger['conditions'], undefined>[0]\n\nexport type StatesComponent = Components['States']\nexport type States = ReturnType<StatesComponent['schema']['deserialize']>\n"]}

package/dist/events.js

@@ -0,0 +1,16 @@
+import mitt from 'mitt';
+const triggers = new Map();
+const actions = new Map();
+export function getTriggerEvents(entity) {
+    if (!triggers.has(entity)) {
+        triggers.set(entity, mitt());
+    }
+    return triggers.get(entity);
+}
+export function getActionEvents(entity) {
+    if (!actions.has(entity)) {
+        actions.set(entity, mitt());
+    }
+    return actions.get(entity);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2V2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLElBQWlCLE1BQU0sTUFBTSxDQUFBO0FBSXBDLE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxFQUE4QyxDQUFBO0FBRXRFLE1BQU0sT0FBTyxHQUFHLElBQUksR0FBRyxFQUdwQixDQUFBO0FBRUgsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE1BQWM7SUFDN0MsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUU7UUFDekIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtLQUM3QjtJQUNELE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUUsQ0FBQTtBQUM5QixDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWUsQ0FBQyxNQUFjO0lBQzVDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7S0FDNUI7SUFDRCxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFFLENBQUE7QUFDN0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBtaXR0LCB7IEVtaXR0ZXIgfSBmcm9tICdtaXR0J1xuaW1wb3J0IHsgRW50aXR5IH0gZnJvbSAnQGRjbC9zZGsvZWNzJ1xuaW1wb3J0IHsgQWN0aW9uUGF5bG9hZCwgQWN0aW9uVHlwZSwgVHJpZ2dlclR5cGUgfSBmcm9tICcuL2RlZmluaXRpb25zJ1xuXG5jb25zdCB0cmlnZ2VycyA9IG5ldyBNYXA8RW50aXR5LCBFbWl0dGVyPFJlY29yZDxUcmlnZ2VyVHlwZSwgdm9pZD4+PigpXG5cbmNvbnN0IGFjdGlvbnMgPSBuZXcgTWFwPFxuICBFbnRpdHksXG4gIEVtaXR0ZXI8UmVjb3JkPHN0cmluZywgQWN0aW9uUGF5bG9hZDxBY3Rpb25UeXBlPj4+XG4+KClcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFRyaWdnZXJFdmVudHMoZW50aXR5OiBFbnRpdHkpIHtcbiAgaWYgKCF0cmlnZ2Vycy5oYXMoZW50aXR5KSkge1xuICAgIHRyaWdnZXJzLnNldChlbnRpdHksIG1pdHQoKSlcbiAgfVxuICByZXR1cm4gdHJpZ2dlcnMuZ2V0KGVudGl0eSkhXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBY3Rpb25FdmVudHMoZW50aXR5OiBFbnRpdHkpIHtcbiAgaWYgKCFhY3Rpb25zLmhhcyhlbnRpdHkpKSB7XG4gICAgYWN0aW9ucy5zZXQoZW50aXR5LCBtaXR0KCkpXG4gIH1cbiAgcmV0dXJuIGFjdGlvbnMuZ2V0KGVudGl0eSkhXG59XG4iXX0=

package/dist/id.js

@@ -0,0 +1,10 @@
+import { ComponentName } from './definitions';
+export function getCounterComponent(engine) {
+    return engine.getComponent(ComponentName.COUNTER);
+}
+export function getNextId(engine) {
+    const Counter = getCounterComponent(engine);
+    const counter = Counter.getOrCreateMutable(engine.RootEntity);
+    return ++counter.value;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFFLGFBQWEsRUFBVyxNQUFNLGVBQWUsQ0FBQTtBQUV0RCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsTUFBZTtJQUNqRCxPQUFPLE1BQU0sQ0FBQyxZQUFZLENBQ3hCLGFBQWEsQ0FBQyxPQUFPLENBQ2dDLENBQUE7QUFDekQsQ0FBQztBQUVELE1BQU0sVUFBVSxTQUFTLENBQUMsTUFBZTtJQUN2QyxNQUFNLE9BQU8sR0FBRyxtQkFBbUIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUMzQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQzdELE9BQU8sRUFBRSxPQUFPLENBQUMsS0FBSyxDQUFBO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBJRW5naW5lLFxuICBMYXN0V3JpdGVXaW5FbGVtZW50U2V0Q29tcG9uZW50RGVmaW5pdGlvbixcbn0gZnJvbSAnQGRjbC9zZGsvZWNzJ1xuaW1wb3J0IHsgQ29tcG9uZW50TmFtZSwgQ291bnRlciB9IGZyb20gJy4vZGVmaW5pdGlvbnMnXG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDb3VudGVyQ29tcG9uZW50KGVuZ2luZTogSUVuZ2luZSkge1xuICByZXR1cm4gZW5naW5lLmdldENvbXBvbmVudChcbiAgICBDb21wb25lbnROYW1lLkNPVU5URVIsXG4gICkgYXMgTGFzdFdyaXRlV2luRWxlbWVudFNldENvbXBvbmVudERlZmluaXRpb248Q291bnRlcj5cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldE5leHRJZChlbmdpbmU6IElFbmdpbmUpIHtcbiAgY29uc3QgQ291bnRlciA9IGdldENvdW50ZXJDb21wb25lbnQoZW5naW5lKVxuICBjb25zdCBjb3VudGVyID0gQ291bnRlci5nZXRPckNyZWF0ZU11dGFibGUoZW5naW5lLlJvb3RFbnRpdHkpXG4gIHJldHVybiArK2NvdW50ZXIudmFsdWVcbn1cbiJdfQ==

package/dist/index.js

@@ -0,0 +1,14 @@
+import { engine, pointerEventsSystem, Animator, Transform, AudioSource, AvatarAttach, VisibilityComponent, GltfContainer, } from '@dcl/sdk/ecs';
+import { initAssetPacks } from './scene-entrypoint';
+initAssetPacks(engine, pointerEventsSystem, {
+    Animator,
+    Transform,
+    AudioSource,
+    AvatarAttach,
+    VisibilityComponent,
+    GltfContainer,
+});
+export function main() {
+    console.log('Scene ready');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLE1BQU0sRUFDTixtQkFBbUIsRUFDbkIsUUFBUSxFQUNSLFNBQVMsRUFDVCxXQUFXLEVBQ1gsWUFBWSxFQUNaLG1CQUFtQixFQUNuQixhQUFhLEdBQ2QsTUFBTSxjQUFjLENBQUE7QUFDckIsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBRW5ELGNBQWMsQ0FBQyxNQUFNLEVBQUUsbUJBQW1CLEVBQUU7SUFDMUMsUUFBUTtJQUNSLFNBQVM7SUFDVCxXQUFXO0lBQ1gsWUFBWTtJQUNaLG1CQUFtQjtJQUNuQixhQUFhO0NBQ2QsQ0FBQyxDQUFBO0FBRUYsTUFBTSxVQUFVLElBQUk7SUFDbEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsQ0FBQTtBQUM1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgZW5naW5lLFxuICBwb2ludGVyRXZlbnRzU3lzdGVtLFxuICBBbmltYXRvcixcbiAgVHJhbnNmb3JtLFxuICBBdWRpb1NvdXJjZSxcbiAgQXZhdGFyQXR0YWNoLFxuICBWaXNpYmlsaXR5Q29tcG9uZW50LFxuICBHbHRmQ29udGFpbmVyLFxufSBmcm9tICdAZGNsL3Nkay9lY3MnXG5pbXBvcnQgeyBpbml0QXNzZXRQYWNrcyB9IGZyb20gJy4vc2NlbmUtZW50cnlwb2ludCdcblxuaW5pdEFzc2V0UGFja3MoZW5naW5lLCBwb2ludGVyRXZlbnRzU3lzdGVtLCB7XG4gIEFuaW1hdG9yLFxuICBUcmFuc2Zvcm0sXG4gIEF1ZGlvU291cmNlLFxuICBBdmF0YXJBdHRhY2gsXG4gIFZpc2liaWxpdHlDb21wb25lbnQsXG4gIEdsdGZDb250YWluZXIsXG59KVxuXG5leHBvcnQgZnVuY3Rpb24gbWFpbigpIHtcbiAgY29uc29sZS5sb2coJ1NjZW5lIHJlYWR5Jylcbn1cbiJdfQ==

package/dist/scene-entrypoint.js

@@ -0,0 +1,17 @@
+import { createComponents, initComponents } from './definitions';
+import { createActionsSystem } from './actions';
+import { createTriggersSystem } from './triggers';
+export function initAssetPacks(_engine, _pointerEventsSystem, components) {
+    const engine = _engine;
+    const pointerEventsSystem = _pointerEventsSystem;
+    try {
+        createComponents(engine);
+        engine.addSystem(createActionsSystem(engine, components));
+        engine.addSystem(createTriggersSystem(engine, pointerEventsSystem));
+        initComponents(engine);
+    }
+    catch (error) {
+        console.error(`Error initializing Asset Packs: ${error.message}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/states.js

@@ -0,0 +1,18 @@
+export function isValidState(states, value) {
+    return !!value && states.value.includes(value);
+}
+export function getCurrentValue(states) {
+    if (isValidState(states, states.currentValue)) {
+        return states.currentValue;
+    }
+    return getDefaultValue(states);
+}
+export function getDefaultValue(states) {
+    if (isValidState(states, states.defaultValue)) {
+        return states.defaultValue;
+    }
+    if (states.value.length > 0) {
+        return states.value[0];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3N0YXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsWUFBWSxDQUFDLE1BQWMsRUFBRSxLQUF5QjtJQUNwRSxPQUFPLENBQUMsQ0FBQyxLQUFLLElBQUksTUFBTSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDaEQsQ0FBQztBQUVELE1BQU0sVUFBVSxlQUFlLENBQUMsTUFBYztJQUM1QyxJQUFJLFlBQVksQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLFlBQVksQ0FBQyxFQUFFO1FBQzdDLE9BQU8sTUFBTSxDQUFDLFlBQWEsQ0FBQTtLQUM1QjtJQUNELE9BQU8sZUFBZSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBQ2hDLENBQUM7QUFFRCxNQUFNLFVBQVUsZUFBZSxDQUFDLE1BQWM7SUFDNUMsSUFBSSxZQUFZLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxZQUFZLENBQUMsRUFBRTtRQUM3QyxPQUFPLE1BQU0sQ0FBQyxZQUFhLENBQUE7S0FDNUI7SUFDRCxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtRQUMzQixPQUFPLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUE7S0FDdkI7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3RhdGVzIH0gZnJvbSAnLi9kZWZpbml0aW9ucydcblxuZXhwb3J0IGZ1bmN0aW9uIGlzVmFsaWRTdGF0ZShzdGF0ZXM6IFN0YXRlcywgdmFsdWU6IHN0cmluZyB8IHVuZGVmaW5lZCkge1xuICByZXR1cm4gISF2YWx1ZSAmJiBzdGF0ZXMudmFsdWUuaW5jbHVkZXModmFsdWUpXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDdXJyZW50VmFsdWUoc3RhdGVzOiBTdGF0ZXMpIHtcbiAgaWYgKGlzVmFsaWRTdGF0ZShzdGF0ZXMsIHN0YXRlcy5jdXJyZW50VmFsdWUpKSB7XG4gICAgcmV0dXJuIHN0YXRlcy5jdXJyZW50VmFsdWUhXG4gIH1cbiAgcmV0dXJuIGdldERlZmF1bHRWYWx1ZShzdGF0ZXMpXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXREZWZhdWx0VmFsdWUoc3RhdGVzOiBTdGF0ZXMpIHtcbiAgaWYgKGlzVmFsaWRTdGF0ZShzdGF0ZXMsIHN0YXRlcy5kZWZhdWx0VmFsdWUpKSB7XG4gICAgcmV0dXJuIHN0YXRlcy5kZWZhdWx0VmFsdWUhXG4gIH1cbiAgaWYgKHN0YXRlcy52YWx1ZS5sZW5ndGggPiAwKSB7XG4gICAgcmV0dXJuIHN0YXRlcy52YWx1ZVswXVxuICB9XG59XG4iXX0=

package/dist/triggers.js

@@ -0,0 +1,191 @@
+import { triggers, LAYER_1, NO_LAYERS } from '@dcl-sdk/utils';
+import { ComponentName, TriggerConditionOperation, TriggerConditionType, TriggerType, getConditionTypesByComponentName, getComponents, } from './definitions';
+import { getCurrentValue } from './states';
+import { getActionEvents, getTriggerEvents } from './events';
+import { getPayload } from './action-types';
+const initedEntities = new Set();
+const actionQueue = [];
+export function createTriggersSystem(engine, pointerEventsSystem) {
+    const { Actions, States, Counter, Triggers } = getComponents(engine);
+    return function triggersSystem(_dt) {
+        while (actionQueue.length > 0) {
+            const { entity, action } = actionQueue.shift();
+            const actionEvents = getActionEvents(entity);
+            actionEvents.emit(action.name, getPayload(action));
+        }
+        const entitiesWithTriggers = engine.getEntitiesWith(Triggers);
+        for (const [entity, triggers] of entitiesWithTriggers) {
+            if (initedEntities.has(entity)) {
+                continue;
+            }
+            const types = triggers.value.reduce((types, trigger) => types.add(trigger.type), new Set());
+            for (const type of types) {
+                switch (type) {
+                    case TriggerType.ON_CLICK: {
+                        initOnClickTrigger(entity);
+                        break;
+                    }
+                    case TriggerType.ON_PLAYER_ENTERS_AREA:
+                    case TriggerType.ON_PLAYER_LEAVES_AREA: {
+                        initOnPlayerTriggerArea(entity);
+                        break;
+                    }
+                }
+            }
+            const triggerEvents = getTriggerEvents(entity);
+            for (const trigger of triggers.value) {
+                triggerEvents.on(trigger.type, () => {
+                    if (checkConditions(trigger)) {
+                        for (const triggerAction of trigger.actions) {
+                            if (isValidAction(triggerAction)) {
+                                const entity = getEntityByAction(triggerAction);
+                                if (entity) {
+                                    const actions = Actions.getOrNull(entity);
+                                    if (actions) {
+                                        const action = actions.value.find(($) => $.name === triggerAction.name);
+                                        if (action) {
+                                            actionQueue.push({ entity, action });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+            triggerEvents.emit(TriggerType.ON_SPAWN);
+            initedEntities.add(entity);
+        }
+    };
+    function isValidAction(action) {
+        const { id, name } = action;
+        return !!id && !!name;
+    }
+    function checkConditions(trigger) {
+        if (trigger.conditions && trigger.conditions.length > 0) {
+            const conditions = trigger.conditions.map(checkCondition);
+            const isTrue = (result) => !!result;
+            const operation = trigger.operation || TriggerConditionOperation.AND;
+            switch (operation) {
+                case TriggerConditionOperation.AND: {
+                    return conditions.every(isTrue);
+                }
+                case TriggerConditionOperation.OR: {
+                    return conditions.some(isTrue);
+                }
+            }
+        }
+        return true;
+    }
+    function checkCondition(condition) {
+        const entity = getEntityByCondition(condition);
+        if (entity) {
+            try {
+                switch (condition.type) {
+                    case TriggerConditionType.WHEN_STATE_IS: {
+                        const states = States.getOrNull(entity);
+                        if (states !== null) {
+                            const currentValue = getCurrentValue(states);
+                            return currentValue === condition.value;
+                        }
+                        break;
+                    }
+                    case TriggerConditionType.WHEN_STATE_IS_NOT: {
+                        const states = States.getOrNull(entity);
+                        if (states !== null) {
+                            const currentValue = getCurrentValue(states);
+                            return currentValue !== condition.value;
+                        }
+                        break;
+                    }
+                    case TriggerConditionType.WHEN_COUNTER_EQUALS: {
+                        const counter = Counter.getOrNull(entity);
+                        if (counter !== null) {
+                            const numeric = Number(condition.value);
+                            if (!isNaN(numeric)) {
+                                return counter.value === numeric;
+                            }
+                        }
+                        break;
+                    }
+                    case TriggerConditionType.WHEN_COUNTER_IS_GREATER_THAN: {
+                        const counter = Counter.getOrNull(entity);
+                        if (counter !== null) {
+                            const numeric = Number(condition.value);
+                            if (!isNaN(numeric)) {
+                                return counter.value > numeric;
+                            }
+                        }
+                        break;
+                    }
+                    case TriggerConditionType.WHEN_COUNTER_IS_LESS_THAN: {
+                        const counter = Counter.getOrNull(entity);
+                        if (counter !== null) {
+                            const numeric = Number(condition.value);
+                            if (!isNaN(numeric)) {
+                                return counter.value < numeric;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error in condition', condition);
+            }
+        }
+        return false;
+    }
+    function getEntityById(componentName, id) {
+        const Component = engine.getComponent(componentName);
+        const entities = Array.from(engine.getEntitiesWith(Component));
+        const result = entities.find(([_entity, value]) => value.id === id);
+        return Array.isArray(result) && result.length > 0 ? result[0] : null;
+    }
+    function getEntityByAction(action) {
+        if (action.id) {
+            const entity = getEntityById(ComponentName.ACTIONS, action.id);
+            if (entity) {
+                return entity;
+            }
+        }
+        return null;
+    }
+    function getEntityByCondition(condition) {
+        const componentName = Object.values(ComponentName)
+            .map((componentName) => ({
+            componentName,
+            conditionTypes: getConditionTypesByComponentName(componentName),
+        }))
+            .reduce((result, { componentName, conditionTypes }) => conditionTypes.includes(condition.type) ? componentName : result, null);
+        if (componentName && condition.id) {
+            const entity = getEntityById(componentName, condition.id);
+            if (entity) {
+                return entity;
+            }
+        }
+        return null;
+    }
+    function initOnClickTrigger(entity) {
+        pointerEventsSystem.onPointerDown({
+            entity,
+            opts: {
+                button: 0,
+                hoverText: 'Click',
+            },
+        }, () => {
+            const triggerEvents = getTriggerEvents(entity);
+            triggerEvents.emit(TriggerType.ON_CLICK);
+        });
+    }
+    function initOnPlayerTriggerArea(entity) {
+        triggers.addTrigger(entity, NO_LAYERS, LAYER_1, [{ type: 'box' }], () => {
+            const triggerEvents = getTriggerEvents(entity);
+            triggerEvents.emit(TriggerType.ON_PLAYER_ENTERS_AREA);
+        }, () => {
+            const triggerEvents = getTriggerEvents(entity);
+            triggerEvents.emit(TriggerType.ON_PLAYER_LEAVES_AREA);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"triggers.js","sourceRoot":"","sources":["../src/triggers.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IEngine,\n  Entity,\n  PointerEventsSystem,\n  InputAction,\n  LastWriteWinElementSetComponentDefinition,\n  DeepReadonlyObject,\n} from '@dcl/sdk/ecs'\nimport { triggers, LAYER_1, NO_LAYERS } from '@dcl-sdk/utils'\nimport {\n  Action,\n  ComponentName,\n  Trigger,\n  TriggerAction,\n  TriggerCondition,\n  TriggerConditionOperation,\n  TriggerConditionType,\n  TriggerType,\n  getConditionTypesByComponentName,\n  getComponents,\n} from './definitions'\nimport { getCurrentValue } from './states'\nimport { getActionEvents, getTriggerEvents } from './events'\nimport { getPayload } from './action-types'\n\nconst initedEntities = new Set<Entity>()\nconst actionQueue: { entity: Entity; action: Action }[] = []\n\nexport function createTriggersSystem(\n  engine: IEngine,\n  pointerEventsSystem: PointerEventsSystem,\n) {\n  const { Actions, States, Counter, Triggers } = getComponents(engine)\n  return function triggersSystem(_dt: number) {\n    // process action queue\n    while (actionQueue.length > 0) {\n      const { entity, action } = actionQueue.shift()!\n      const actionEvents = getActionEvents(entity)\n      actionEvents.emit(action.name, getPayload(action))\n    }\n\n    const entitiesWithTriggers = engine.getEntitiesWith(Triggers)\n    for (const [entity, triggers] of entitiesWithTriggers) {\n      if (initedEntities.has(entity)) {\n        continue\n      }\n\n      // initialize triggers for given entity\n      const types = triggers.value.reduce(\n        (types, trigger) => types.add(trigger.type),\n        new Set<TriggerType>(),\n      )\n      for (const type of types) {\n        switch (type) {\n          case TriggerType.ON_CLICK: {\n            initOnClickTrigger(entity)\n            break\n          }\n          case TriggerType.ON_PLAYER_ENTERS_AREA:\n          case TriggerType.ON_PLAYER_LEAVES_AREA: {\n            initOnPlayerTriggerArea(entity)\n            break\n          }\n        }\n      }\n\n      // bind triggers\n      const triggerEvents = getTriggerEvents(entity)\n      for (const trigger of triggers.value) {\n        triggerEvents.on(trigger.type, () => {\n          if (checkConditions(trigger)) {\n            for (const triggerAction of trigger.actions) {\n              if (isValidAction(triggerAction)) {\n                const entity = getEntityByAction(triggerAction)\n                if (entity) {\n                  const actions = Actions.getOrNull(entity)\n                  if (actions) {\n                    const action = actions.value.find(\n                      ($) => $.name === triggerAction.name,\n                    )\n                    if (action) {\n                      // actions are enqueued to be executed on the next tick after all the triggers have been processed,\n                      // this is to avoid one trigger messing with other trigger's conditions\n                      actionQueue.push({ entity, action })\n                    }\n                  }\n                }\n              }\n            }\n          }\n        })\n      }\n      triggerEvents.emit(TriggerType.ON_SPAWN)\n\n      initedEntities.add(entity)\n    }\n  }\n\n  function isValidAction(action: TriggerAction) {\n    const { id, name } = action\n    return !!id && !!name\n  }\n\n  function checkConditions(trigger: DeepReadonlyObject<Trigger>) {\n    if (trigger.conditions && trigger.conditions.length > 0) {\n      const conditions = trigger.conditions.map(checkCondition)\n      const isTrue = (result?: boolean) => !!result\n      const operation = trigger.operation || TriggerConditionOperation.AND\n      switch (operation) {\n        case TriggerConditionOperation.AND: {\n          return conditions.every(isTrue)\n        }\n        case TriggerConditionOperation.OR: {\n          return conditions.some(isTrue)\n        }\n      }\n    }\n    // if there are no conditions, the trigger can continue\n    return true\n  }\n\n  function checkCondition(condition: TriggerCondition) {\n    const entity = getEntityByCondition(condition)\n    if (entity) {\n      try {\n        switch (condition.type) {\n          case TriggerConditionType.WHEN_STATE_IS: {\n            const states = States.getOrNull(entity)\n            if (states !== null) {\n              const currentValue = getCurrentValue(states)\n              return currentValue === condition.value\n            }\n            break\n          }\n          case TriggerConditionType.WHEN_STATE_IS_NOT: {\n            const states = States.getOrNull(entity)\n            if (states !== null) {\n              const currentValue = getCurrentValue(states)\n              return currentValue !== condition.value\n            }\n            break\n          }\n          case TriggerConditionType.WHEN_COUNTER_EQUALS: {\n            const counter = Counter.getOrNull(entity)\n            if (counter !== null) {\n              const numeric = Number(condition.value)\n              if (!isNaN(numeric)) {\n                return counter.value === numeric\n              }\n            }\n            break\n          }\n          case TriggerConditionType.WHEN_COUNTER_IS_GREATER_THAN: {\n            const counter = Counter.getOrNull(entity)\n            if (counter !== null) {\n              const numeric = Number(condition.value)\n              if (!isNaN(numeric)) {\n                return counter.value > numeric\n              }\n            }\n            break\n          }\n          case TriggerConditionType.WHEN_COUNTER_IS_LESS_THAN: {\n            const counter = Counter.getOrNull(entity)\n            if (counter !== null) {\n              const numeric = Number(condition.value)\n              if (!isNaN(numeric)) {\n                return counter.value < numeric\n              }\n            }\n            break\n          }\n        }\n      } catch (error) {\n        console.error('Error in condition', condition)\n      }\n    }\n    return false\n  }\n\n  function getEntityById<T extends { id: number }>(\n    componentName: string,\n    id: number,\n  ) {\n    const Component = engine.getComponent(\n      componentName,\n    ) as LastWriteWinElementSetComponentDefinition<T>\n    const entities = Array.from(engine.getEntitiesWith(Component))\n    const result = entities.find(([_entity, value]) => value.id === id)\n    return Array.isArray(result) && result.length > 0 ? result[0] : null\n  }\n\n  function getEntityByAction(action: TriggerAction) {\n    if (action.id) {\n      const entity = getEntityById(ComponentName.ACTIONS, action.id)\n      if (entity) {\n        return entity\n      }\n    }\n    return null\n  }\n\n  function getEntityByCondition(condition: TriggerCondition) {\n    const componentName = Object.values(ComponentName)\n      .map((componentName) => ({\n        componentName,\n        conditionTypes: getConditionTypesByComponentName(componentName),\n      }))\n      .reduce<ComponentName | null>(\n        (result, { componentName, conditionTypes }) =>\n          conditionTypes.includes(condition.type) ? componentName : result,\n        null,\n      )\n    if (componentName && condition.id) {\n      const entity = getEntityById(componentName, condition.id)\n      if (entity) {\n        return entity\n      }\n    }\n    return null\n  }\n\n  // ON_CLICK\n  function initOnClickTrigger(entity: Entity) {\n    pointerEventsSystem.onPointerDown(\n      {\n        entity,\n        opts: {\n          button: InputAction.IA_POINTER,\n          hoverText: 'Click',\n        },\n      },\n      () => {\n        const triggerEvents = getTriggerEvents(entity)\n        triggerEvents.emit(TriggerType.ON_CLICK)\n      },\n    )\n  }\n\n  function initOnPlayerTriggerArea(entity: Entity) {\n    triggers.addTrigger(\n      entity,\n      NO_LAYERS,\n      LAYER_1,\n      [{ type: 'box' }],\n      () => {\n        const triggerEvents = getTriggerEvents(entity)\n        triggerEvents.emit(TriggerType.ON_PLAYER_ENTERS_AREA)\n      },\n      () => {\n        const triggerEvents = getTriggerEvents(entity)\n        triggerEvents.emit(TriggerType.ON_PLAYER_LEAVES_AREA)\n      },\n    )\n  }\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/asset-packs",
-  "version": "1.2.1",
+  "version": "1.2.2-20231010134915.commit-6abb6ed",
   "description": "",
   "main": "dist/src/definitions.js",
   "typings": "dist/src/definitions.d.ts",
@@ -59,5 +59,5 @@
     "semi": false,
     "printWidth": 80
   },
-  "commit": "4b75adb8857e57658ccce243235974cfccc70610"
+  "commit": "6abb6edf84d2b90295909ae5a91b974784d9fa4c"
 }

package/dist/package.json

@@ -1,62 +0,0 @@
-{
-    "name": "@dcl/asset-packs",
-    "version": "0.0.0",
-    "description": "",
-    "main": "dist/src/definitions.js",
-    "typings": "dist/src/definitions.d.ts",
-    "scripts": {
-        "download": "ts-node --project tsconfig.scripts.json ./scripts/download.ts",
-        "validate": "ts-node --project tsconfig.scripts.json ./scripts/validate.ts",
-        "upload": "ts-node --project tsconfig.scripts.json ./scripts/upload.ts",
-        "start": "concurrently \"npm run start:js\" \"npm run start:lib\" \"npm run start:catalog\"",
-        "start:js": "sdk-commands start --no-browser",
-        "start:lib": "npm run build:lib -- --watch",
-        "start:catalog": "nodemon --watch packs -x \"npm run build:catalog\"",
-        "build:js": "sdk-commands build",
-        "build:lib": "tsc --project tsconfig.lib.json",
-        "build:catalog": "ts-node --project tsconfig.scripts.json ./scripts/catalog.ts",
-        "build": "npm run build:js && npm run build:lib && npm run build:catalog"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/decentraland/asset-packs.git"
-    },
-    "keywords": [],
-    "author": "",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://github.com/decentraland/asset-packs/issues"
-    },
-    "homepage": "https://github.com/decentraland/asset-packs#readme",
-    "devDependencies": {
-        "@aws-sdk/client-s3": "^3.405.0",
-        "@aws-sdk/lib-storage": "^3.405.0",
-        "@dcl/hashing": "^3.0.4",
-        "@types/mime-types": "^2.1.1",
-        "@types/node-fetch": "^2.6.4",
-        "concurrently": "^8.2.1",
-        "dotenv": "^16.3.1",
-        "fp-future": "^1.0.1",
-        "mime-types": "^2.1.35",
-        "node-fetch": "^2.7.0",
-        "nodemon": "^3.0.1",
-        "p-queue": "^7.4.1",
-        "prettier": "^3.0.2",
-        "rimraf": "^5.0.1",
-        "serve": "^14.2.1",
-        "serve-handler": "^6.1.5",
-        "ts-node": "^10.9.1",
-        "typescript": "^5.1.6"
-    },
-    "dependencies": {
-        "@dcl-sdk/utils": "^1.1.3",
-        "@dcl/js-runtime": "7.3.18",
-        "@dcl/sdk": "^7.3.18",
-        "mitt": "^3.0.1"
-    },
-    "prettier": {
-        "singleQuote": true,
-        "semi": false,
-        "printWidth": 80
-    }
-}