@mapples/inlang 1.0.0

package/README.md

@@ -0,0 +1,454 @@
+# @mapples/types
+
+TypeScript type definitions for the Mapples Open Kit. This package provides all the core type definitions used across the Mapples ecosystem, including component registration, form configurations, and asset management.
+
+## Installation
+
+```bash
+npm install @mapples/types
+# or
+yarn add @mapples/types
+```
+
+## Overview
+
+The `@mapples/types` package contains essential TypeScript interfaces and types that define the structure and behavior of components, forms, and assets in the Mapples system. These types ensure type safety and provide clear contracts for developers working with the Mapples Open Kit.
+
+## Core Types
+
+### Action Types
+
+#### `Action`
+
+Represents a user action that occurred in the application. Actions are used for tracking user interactions, analytics, and state management.
+
+```typescript
+interface Action {
+  time: number; // Timestamp when the action occurred (in milliseconds since epoch)
+  type?: string; // Optional string identifier for the type of action
+  payload?: ActionPayload; // Optional payload containing additional data about the action
+}
+```
+
+#### `ActionPayload`
+
+Represents the payload data that can be attached to an action.
+
+```typescript
+interface ActionPayload {
+  originalEventData?: any[]; // Original event data from the source event
+  data?: any; // Custom data payload specific to the action
+}
+```
+
+**Example:**
+
+```typescript
+import { Action, ActionPayload } from '@mapples/types';
+
+const userAction: Action = {
+  time: Date.now(),
+  type: 'BUTTON_PRESSED',
+  payload: {
+    data: { buttonId: 'submit', userId: '123' },
+    originalEventData: ['button', 'press', { x: 100, y: 200 }],
+  },
+};
+```
+
+### Mapplet Types
+
+#### `MappletType<State>`
+
+Represents the configuration interface for a Mapplet application. A Mapplet is a self-contained application that can be embedded or run standalone.
+
+```typescript
+interface MappletType<State extends object = object> {
+  state?: State; // Optional initial state object for the Mapplet
+  onAction?: (action: Action) => void; // Optional callback function to handle actions
+}
+```
+
+**Example:**
+
+```typescript
+import { MappletType, Action } from '@mapples/types';
+
+interface MyAppState {
+  user: { name: string; email: string };
+  settings: { theme: string };
+}
+
+const myMapplet: MappletType<MyAppState> = {
+  state: {
+    user: { name: 'John', email: 'john@example.com' },
+    settings: { theme: 'dark' },
+  },
+  onAction: (action: Action) => {
+    console.log('Mapplet action:', action);
+    // Handle analytics, logging, etc.
+  },
+};
+```
+
+### Asset Types
+
+#### `AssetType`
+
+Represents the different types of assets that can be used in the Mapples system.
+
+```typescript
+type AssetType = 'image' | 'video' | 'icon' | 'font' | 'json';
+```
+
+**Example:**
+
+```typescript
+import { AssetType } from '@mapples/types';
+
+const imageAsset: AssetType = 'image';
+const videoAsset: AssetType = 'video';
+```
+
+### Component Types
+
+#### `RegisteredComponent<T>`
+
+Defines the structure for registering components in the Mapples component system. This interface contains all the metadata needed to make a component available in the visual editor.
+
+```typescript
+interface RegisteredComponent<T extends object = object> {
+  type: string; // Unique component identifier
+  groupId: string; // Group this component belongs to
+  label: string; // Display name
+  Component: ComponentType<PropsWithChildren<T>>; // React component
+  Icon: ComponentType<SvgProps>; // Icon for component palette
+  initialProps: T; // Default props
+  styleKeys: StyleKey[]; // Available style properties
+  props: PropsFormField[]; // Property form fields
+  actionProps: string[]; // Action-triggering properties
+  hidden?: boolean; // Hide from palette
+  hasChildren?: boolean; // Can contain children
+}
+```
+
+**Example:**
+
+```typescript
+import { RegisteredComponent } from '@mapples/types';
+
+interface ButtonProps {
+  text: string;
+  disabled?: boolean;
+  onPress?: () => void;
+}
+
+const buttonComponent: RegisteredComponent<ButtonProps> = {
+  type: 'Button',
+  groupId: 'inputs',
+  label: 'Button',
+  Component: Button,
+  Icon: ButtonIcon,
+  initialProps: { text: 'Click me' },
+  styleKeys: [backgroundColorStyle, textColorStyle],
+  props: [textField, disabledField],
+  actionProps: ['onPress'],
+};
+```
+
+#### `RegisteredComponentsGroup`
+
+Represents a group of components in the component palette.
+
+```typescript
+interface RegisteredComponentsGroup {
+  id: string; // Unique group identifier
+  label: string; // Display name
+  Icon: ComponentType<SvgProps>; // Group icon
+}
+```
+
+#### `RegisteredComponents`
+
+A registry mapping component types to their definitions.
+
+```typescript
+type RegisteredComponents = Record<string, RegisteredComponent>;
+```
+
+#### `StyleKey`
+
+Defines a style property configuration.
+
+```typescript
+interface StyleKey {
+  label: string; // Human-readable label
+  value: string; // CSS property name
+  forms: StyleFormType[]; // Applicable form types
+}
+```
+
+### Form Types
+
+#### `StyleFormType`
+
+Enum representing different categories of style forms.
+
+```typescript
+enum StyleFormType {
+  Dimension = 'Dimension', // Width, height, min/max dimensions
+  Image = 'Image', // Background images, object fit
+  Text = 'Text', // Text color, alignment
+  Typography = 'Typography', // Font family, size, weight
+  Position = 'Position', // Top, left, right, bottom
+  Surface = 'Surface', // Background color, opacity
+  ScrollSurface = 'ScrollSurface', // Scrollable surface properties
+  Borders = 'Borders', // Border width, color, radius
+  Shadow = 'Shadow', // Box shadow, elevation
+  Spacing = 'Spacing', // Margin, padding
+  Svg = 'Svg', // SVG-related properties
+}
+```
+
+#### `PropsFormType`
+
+Enum for property form field types.
+
+```typescript
+enum PropsFormType {
+  Text = 'Text', // Text input field
+  Select = 'Select', // Single selection dropdown
+  Switch = 'Switch', // Boolean toggle
+  MultiSelect = 'MultiSelect', // Multiple selection dropdown
+}
+```
+
+#### `PropsFormField`
+
+Configuration for component property form fields.
+
+```typescript
+interface PropsFormField {
+  propsKey: string; // Property key in component props
+  label: string; // Form field label
+  options?: PropsFormFieldOptions; // Options for select fields
+  type: PropsFormType; // Form field type
+  dataProp?: boolean; // Can be bound to data sources
+}
+```
+
+**Example:**
+
+```typescript
+import { PropsFormField, PropsFormType } from '@mapples/types';
+
+const textField: PropsFormField = {
+  propsKey: 'text',
+  label: 'Button Text',
+  type: PropsFormType.Text,
+};
+
+const sizeField: PropsFormField = {
+  propsKey: 'size',
+  label: 'Size',
+  type: PropsFormType.Select,
+  options: [
+    { label: 'Small', value: 'sm' },
+    { label: 'Medium', value: 'md' },
+    { label: 'Large', value: 'lg' },
+  ],
+};
+```
+
+#### `PropsFormFieldOption`
+
+Represents an option in select/multi-select fields.
+
+```typescript
+interface PropsFormFieldOption {
+  label: string; // Display text
+  value: string; // Stored value
+}
+```
+
+#### `PropsFormFieldOptions`
+
+Union type for form field options.
+
+```typescript
+type PropsFormFieldOptions =
+  | PropsFormFieldOption[] // Array of options
+  | 'typography' // Special typography type
+  | AssetType; // Asset type for asset selection
+```
+
+#### `ActionFormProps`
+
+Configuration for action properties.
+
+```typescript
+interface ActionFormProps {
+  propsKey: string; // Action property key
+  label: string; // Form field label
+}
+```
+
+#### `PropsFieldConfig`
+
+Mapping of form types to their React components.
+
+```typescript
+type PropsFieldConfig = Record<PropsFormType, ComponentType<PropsFormField>>;
+```
+
+## Usage Examples
+
+### Registering a Component
+
+```typescript
+import {
+  RegisteredComponent,
+  PropsFormField,
+  PropsFormType,
+  StyleFormType,
+  StyleKey,
+} from '@mapples/types';
+
+// Define component props
+interface MyButtonProps {
+  text: string;
+  variant: 'primary' | 'secondary';
+  disabled?: boolean;
+}
+
+// Create style keys
+const backgroundColorStyle: StyleKey = {
+  label: 'Background Color',
+  value: 'backgroundColor',
+  forms: [StyleFormType.Surface],
+};
+
+// Create form fields
+const textField: PropsFormField = {
+  propsKey: 'text',
+  label: 'Button Text',
+  type: PropsFormType.Text,
+};
+
+const variantField: PropsFormField = {
+  propsKey: 'variant',
+  label: 'Variant',
+  type: PropsFormType.Select,
+  options: [
+    { label: 'Primary', value: 'primary' },
+    { label: 'Secondary', value: 'secondary' },
+  ],
+};
+
+// Register the component
+const myButtonComponent: RegisteredComponent<MyButtonProps> = {
+  type: 'MyButton',
+  groupId: 'custom',
+  label: 'My Button',
+  Component: MyButton,
+  Icon: MyButtonIcon,
+  initialProps: {
+    text: 'Click me',
+    variant: 'primary',
+  },
+  styleKeys: [backgroundColorStyle],
+  props: [textField, variantField],
+  actionProps: ['onPress'],
+};
+```
+
+### Creating a Component Group
+
+```typescript
+import { RegisteredComponentsGroup } from '@mapples/types';
+
+const customGroup: RegisteredComponentsGroup = {
+  id: 'custom',
+  label: 'Custom Components',
+  Icon: CustomIcon,
+};
+```
+
+### Working with Form Fields
+
+```typescript
+import {
+  PropsFormField,
+  PropsFormType,
+  PropsFormFieldOptions,
+} from '@mapples/types';
+
+// Text field
+const nameField: PropsFormField = {
+  propsKey: 'name',
+  label: 'Name',
+  type: PropsFormType.Text,
+};
+
+// Select field with options
+const statusField: PropsFormField = {
+  propsKey: 'status',
+  label: 'Status',
+  type: PropsFormType.Select,
+  options: [
+    { label: 'Active', value: 'active' },
+    { label: 'Inactive', value: 'inactive' },
+    { label: 'Pending', value: 'pending' },
+  ],
+};
+
+// Asset selection field
+const imageField: PropsFormField = {
+  propsKey: 'image',
+  label: 'Image',
+  type: PropsFormType.Select,
+  options: 'image', // AssetType
+};
+
+// Typography field
+const fontField: PropsFormField = {
+  propsKey: 'font',
+  label: 'Font',
+  type: PropsFormType.Select,
+  options: 'typography',
+};
+```
+
+## Integration with Other Packages
+
+This types package is used throughout the Mapples ecosystem:
+
+- **@mapples/action**: Uses `Action` and `ActionPayload` types for action management
+- **@mapples/state**: Uses state-related types for state management
+- **@mapples/ui**: Uses `RegisteredComponent` and related types for component registration
+- **@mapples/form**: Uses `PropsFormField` and form-related types for property editing
+- **@mapples/style**: Uses `StyleKey` and `StyleFormType` for styling configuration
+- **@mapples/render**: Uses component types for rendering components
+
+## Type Safety
+
+All types in this package are designed to provide maximum type safety and IntelliSense support. When working with Mapples components, you'll get:
+
+- Autocomplete for all properties
+- Type checking for component props
+- Validation for form field configurations
+- IntelliSense for style properties
+
+## Contributing
+
+When adding new types to this package:
+
+1. Follow the existing naming conventions
+2. Add comprehensive TSDoc comments
+3. Include usage examples
+4. Update this README with new types
+5. Ensure all types are exported from the main index file
+
+## License
+
+MIT

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const FN_SEPARATOR = "::";
+export declare const DATA_THIS = "(this)";
+export declare const DOT_SEPARATOR = ".";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,OAAO,CAAC;AACjC,eAAO,MAAM,SAAS,WAAW,CAAC;AAClC,eAAO,MAAM,aAAa,MAAM,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const FN_SEPARATOR = '::';
+export const DATA_THIS = '(this)';
+export const DOT_SEPARATOR = '.';
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC;AACjC,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAClC,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,CAAC"}

package/dist/dims.d.ts

@@ -0,0 +1,5 @@
+export type DimType = 'width' | 'height';
+export type Dims = [DimType, number];
+export type DimsString = 'w' | 'h' | 'width' | 'height';
+export declare const parseDims: (dim: string) => Dims | null;
+//# sourceMappingURL=dims.d.ts.map

package/dist/dims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dims.d.ts","sourceRoot":"","sources":["../src/dims.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;AACzC,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AACrC,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,GAAG,QAAQ,CAAC;AASxD,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,KAAG,IAAI,GAAG,IAS9C,CAAC"}

package/dist/dims.js

@@ -0,0 +1,17 @@
+import { FN_SEPARATOR } from './constants';
+const dimRegExp = new RegExp(`^"(w|h|width|height)(${FN_SEPARATOR}\\d+)?"$`);
+const mapDimsType = {
+    w: 'width',
+    h: 'height',
+    width: 'width',
+    height: 'height',
+};
+export const parseDims = (dim) => {
+    if (dimRegExp.test(dim)) {
+        const [type, percent] = dim.slice(1, -1).split(FN_SEPARATOR);
+        const value = parseInt(percent || '', 10);
+        return [mapDimsType[type], !isNaN(value) ? value / 100 : 1];
+    }
+    return null;
+};
+//# sourceMappingURL=dims.js.map

package/dist/dims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dims.js","sourceRoot":"","sources":["../src/dims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,SAAS,GAAG,IAAI,MAAM,CAAC,wBAAwB,YAAY,UAAU,CAAC,CAAC;AAM7E,MAAM,WAAW,GAAG;IAClB,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,QAAQ;IACX,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;CACR,CAAC;AAEX,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,GAAW,EAAe,EAAE;IACpD,IAAI,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;QAE1C,OAAO,CAAC,WAAW,CAAC,IAAkB,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './this';
+export * from './state';
+export * from './dims';
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './this';
+export * from './state';
+export * from './dims';
+export * from './constants';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC"}

package/dist/state/conditions.d.ts

@@ -0,0 +1,5 @@
+import { ConditionFunc, Conditions } from './types';
+export declare const eq: ConditionFunc;
+export declare const notEq: ConditionFunc;
+export declare const conditionMap: Record<Conditions, ConditionFunc>;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/state/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/state/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,EAAE,EAAE,aAAiC,CAAC;AACnD,eAAO,MAAM,KAAK,EAAE,aAAiC,CAAC;AAEtD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,UAAU,EAAE,aAAa,CAG1D,CAAC"}

package/dist/state/conditions.js

@@ -0,0 +1,8 @@
+import { Conditions } from './types';
+export const eq = (a, b) => a === b;
+export const notEq = (a, b) => a !== b;
+export const conditionMap = {
+    [Conditions.equals]: eq,
+    [Conditions.notEquals]: notEq,
+};
+//# sourceMappingURL=conditions.js.map

package/dist/state/conditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.js","sourceRoot":"","sources":["../../src/state/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,UAAU,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,CAAC,MAAM,EAAE,GAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AACnD,MAAM,CAAC,MAAM,KAAK,GAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AAEtD,MAAM,CAAC,MAAM,YAAY,GAAsC;IAC7D,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,EAAE;IACvB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,KAAK;CAC9B,CAAC"}

package/dist/state/index.d.ts

@@ -0,0 +1,5 @@
+export * from './regexp';
+export * from './types';
+export * from './utils';
+export * from './conditions';
+//# sourceMappingURL=index.d.ts.map

package/dist/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/state/index.js

@@ -0,0 +1,5 @@
+export * from './regexp';
+export * from './types';
+export * from './utils';
+export * from './conditions';
+//# sourceMappingURL=index.js.map

package/dist/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/state/regexp.d.ts

@@ -0,0 +1,2 @@
+export declare const ConditionStringRegExp: RegExp;
+//# sourceMappingURL=regexp.d.ts.map

package/dist/state/regexp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexp.d.ts","sourceRoot":"","sources":["../../src/state/regexp.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,QAAkC,CAAC"}

package/dist/state/regexp.js

@@ -0,0 +1,2 @@
+export const ConditionStringRegExp = /::(?=(?:[^"]*"[^"]*")*[^"]*$)/;
+//# sourceMappingURL=regexp.js.map

package/dist/state/regexp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexp.js","sourceRoot":"","sources":["../../src/state/regexp.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAAG,+BAA+B,CAAC"}

package/dist/state/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Enumeration of condition operators for evaluating data properties.
+ *
+ * Used in condition strings to specify how to compare a data property value
+ * against another value.
+ *
+ * @enum Conditions
+ * @public
+ */
+export declare enum Conditions {
+    /** Equality condition - checks if values are equal */
+    equals = "eq",
+    /** Not equals condition - checks if values are not equal */
+    notEquals = "neq"
+}
+/**
+ * Type representing a simple condition string.
+ *
+ * Format: `${dataProp}::${condition}::${value}`
+ * where dataProp is a path, condition is a Conditions operator, and value is a string.
+ *
+ * @type SimpleCondition
+ * @public
+ */
+export type SimpleCondition = `${string}::${Conditions}::${string}`;
+/**
+ * Type representing a boolean condition string.
+ *
+ * Format: `${dataProp}::${condition}::${'true' | 'false'}`
+ * Used for conditions that compare against boolean values.
+ *
+ * @type BoolCondition
+ * @public
+ */
+export type BoolCondition = `${string}::${Conditions}::${'true' | 'false'}`;
+/**
+ * Function type for condition evaluation.
+ *
+ * Takes two values and returns a boolean indicating whether the condition is met.
+ *
+ * @type ConditionFunc
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns True if the condition is satisfied, false otherwise
+ * @public
+ */
+export type ConditionFunc = (a: unknown, b: unknown) => boolean;
+/**
+ * Type representing the type of a value in a condition.
+ *
+ * @type ValueType
+ * @public
+ */
+export type ValueType = 'string' | 'number' | 'boolean' | 'dataProp';
+/**
+ * Result of parsing a condition string.
+ *
+ * Contains the parsed components of a condition string including the data property path,
+ * the condition operator, the value to compare against, and the type of that value.
+ *
+ * @interface ParseConditionResult
+ * @property {string} dataProp - The data property path to evaluate
+ * @property {Conditions} condition - The condition operator to use
+ * @property {string | boolean} valueProp - The value to compare against
+ * @property {ValueType} valueType - The type of the value (string, number, boolean, or dataProp)
+ * @public
+ */
+export interface ParseConditionResult {
+    dataProp: string;
+    condition: Conditions;
+    valueProp: string | boolean;
+    valueType: ValueType;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/state/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/state/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,UAAU;IACpB,sDAAsD;IACtD,MAAM,OAAO;IACb,4DAA4D;IAC5D,SAAS,QAAQ;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,GAAG,MAAM,KAAK,UAAU,KAAK,MAAM,EAAE,CAAC;AAEpE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,MAAM,KAAK,UAAU,KAAK,MAAM,GAAG,OAAO,EAAE,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,SAAS,EAAE,SAAS,CAAC;CACtB"}

package/dist/state/types.js

@@ -0,0 +1,17 @@
+/**
+ * Enumeration of condition operators for evaluating data properties.
+ *
+ * Used in condition strings to specify how to compare a data property value
+ * against another value.
+ *
+ * @enum Conditions
+ * @public
+ */
+export var Conditions;
+(function (Conditions) {
+    /** Equality condition - checks if values are equal */
+    Conditions["equals"] = "eq";
+    /** Not equals condition - checks if values are not equal */
+    Conditions["notEquals"] = "neq";
+})(Conditions || (Conditions = {}));
+//# sourceMappingURL=types.js.map

package/dist/state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/state/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAN,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,sDAAsD;IACtD,2BAAa,CAAA;IACb,4DAA4D;IAC5D,+BAAiB,CAAA;AACnB,CAAC,EALW,UAAU,KAAV,UAAU,QAKrB"}

package/dist/state/utils.d.ts

@@ -0,0 +1,93 @@
+import { BoolCondition, ParseConditionResult, SimpleCondition } from './types';
+export declare const toConditionString: (...values: string[]) => string;
+export declare const parseConditionString: (value: string) => ParseConditionResult;
+/**
+ * Parses a condition string into its component parts.
+ *
+ * Condition strings follow the format: `dataProp::condition::value`
+ * - `dataProp`: The data property path to evaluate
+ * - `condition`: The condition operator (eq, neq)
+ * - `value`: The value to compare against (can be a string, boolean, or dataProp reference)
+ *
+ * @param value - The condition string to parse (e.g., "user.age::eq::18" or "user.active::eq::true")
+ * @returns A parsed condition result with dataProp, condition, valueProp, and valueType
+ *
+ * @example
+ * ```tsx
+ * const result = parseCondition("user.age::eq::18");
+ * // Returns: { dataProp: "user.age", condition: Conditions.equals, valueProp: "18", valueType: "dataProp" }
+ *
+ * const boolResult = parseCondition("user.active::eq::true");
+ * // Returns: { dataProp: "user.active", condition: Conditions.equals, valueProp: true, valueType: "boolean" }
+ * ```
+ *
+ * @public
+ */
+export declare const parseCondition: (value: SimpleCondition | BoolCondition) => ParseConditionResult;
+/**
+ * Type guard that checks if a value is a valid condition string.
+ *
+ * Valid condition strings follow the pattern: `dataProp::condition::value`
+ * where:
+ * - `dataProp` is alphanumeric with dots and underscores
+ * - `condition` is alphanumeric with underscores
+ * - `value` can be a quoted string, alphanumeric, or empty
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid condition string, false otherwise
+ *
+ * @example
+ * ```tsx
+ * isCondition("user.age::eq::18"); // true
+ * isCondition("user.active::eq::true"); // true
+ * isCondition("invalid"); // false
+ * isCondition(123); // false
+ * ```
+ *
+ * @public
+ */
+export declare const isCondition: (value: unknown) => value is SimpleCondition;
+/**
+ * Converts a string or boolean value to a boolean.
+ *
+ * String values are converted by checking if they equal the string "true".
+ * Boolean values are returned as-is.
+ *
+ * @param value - The value to convert (string or boolean)
+ * @returns The boolean representation of the value
+ *
+ * @example
+ * ```tsx
+ * toBool("true"); // true
+ * toBool("false"); // false
+ * toBool(true); // true
+ * toBool(false); // false
+ * toBool("yes"); // false
+ * ```
+ *
+ * @public
+ */
+export declare const toBool: (value: string | boolean) => boolean;
+/**
+ * Converts a string or boolean value to a number.
+ *
+ * - Boolean values: true becomes 1, false becomes 0
+ * - String values: parsed using Number(), returns 0 if NaN
+ *
+ * @param value - The value to convert (string or boolean)
+ * @returns The numeric representation of the value (0 if conversion fails)
+ *
+ * @example
+ * ```tsx
+ * toNumber("123"); // 123
+ * toNumber("45.67"); // 45.67
+ * toNumber(true); // 1
+ * toNumber(false); // 0
+ * toNumber("invalid"); // 0
+ * ```
+ *
+ * @public
+ */
+export declare const toNumber: (value: string | boolean) => number;
+export declare const parseJoin: (key: string) => string[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/state/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/state/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,aAAa,EAEb,oBAAoB,EACpB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAWjB,eAAO,MAAM,iBAAiB,GAAI,GAAG,QAAQ,MAAM,EAAE,WAEpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,KAAG,oBAWpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,eAAe,GAAG,aAAa,KACrC,oBAgCF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAKrD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,GAAG,OAAO,YAI7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,GAAG,OAAO,WAU/C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,aAEpC,CAAC"}

package/dist/state/utils.js

@@ -0,0 +1,158 @@
+import { FN_SEPARATOR } from '@mapples/inlang';
+import { ConditionStringRegExp } from './regexp';
+const mapTypes = {
+    str: 'string',
+    num: 'number',
+    bool: 'boolean',
+    string: 'string',
+    number: 'number',
+    boolean: 'boolean',
+};
+export const toConditionString = (...values) => {
+    return values.join(FN_SEPARATOR);
+};
+export const parseConditionString = (value) => {
+    const [dataProp, condition, valueProp] = value
+        .trim()
+        .split(ConditionStringRegExp);
+    return {
+        dataProp,
+        condition: condition,
+        valueProp: valueProp,
+        valueType: 'string',
+    };
+};
+/**
+ * Parses a condition string into its component parts.
+ *
+ * Condition strings follow the format: `dataProp::condition::value`
+ * - `dataProp`: The data property path to evaluate
+ * - `condition`: The condition operator (eq, neq)
+ * - `value`: The value to compare against (can be a string, boolean, or dataProp reference)
+ *
+ * @param value - The condition string to parse (e.g., "user.age::eq::18" or "user.active::eq::true")
+ * @returns A parsed condition result with dataProp, condition, valueProp, and valueType
+ *
+ * @example
+ * ```tsx
+ * const result = parseCondition("user.age::eq::18");
+ * // Returns: { dataProp: "user.age", condition: Conditions.equals, valueProp: "18", valueType: "dataProp" }
+ *
+ * const boolResult = parseCondition("user.active::eq::true");
+ * // Returns: { dataProp: "user.active", condition: Conditions.equals, valueProp: true, valueType: "boolean" }
+ * ```
+ *
+ * @public
+ */
+export const parseCondition = (value) => {
+    const [dataProp, condition, valueProp] = value
+        .trim()
+        .split(ConditionStringRegExp);
+    if (valueProp === 'true' || valueProp === 'false')
+        return {
+            dataProp,
+            condition: condition,
+            valueProp: valueProp === 'true',
+            valueType: 'boolean',
+        };
+    if (/^"[^"]*"$/.test(valueProp)) {
+        const parsedValue = valueProp.slice(1, -1);
+        const [value, type] = parsedValue.split(FN_SEPARATOR);
+        return {
+            dataProp,
+            condition: condition,
+            valueProp: value,
+            valueType: mapTypes[type] || 'string',
+        };
+    }
+    return {
+        dataProp,
+        condition: condition,
+        valueProp,
+        valueType: 'dataProp',
+    };
+};
+/**
+ * Type guard that checks if a value is a valid condition string.
+ *
+ * Valid condition strings follow the pattern: `dataProp::condition::value`
+ * where:
+ * - `dataProp` is alphanumeric with dots and underscores
+ * - `condition` is alphanumeric with underscores
+ * - `value` can be a quoted string, alphanumeric, or empty
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid condition string, false otherwise
+ *
+ * @example
+ * ```tsx
+ * isCondition("user.age::eq::18"); // true
+ * isCondition("user.active::eq::true"); // true
+ * isCondition("invalid"); // false
+ * isCondition(123); // false
+ * ```
+ *
+ * @public
+ */
+export const isCondition = (value) => {
+    return (typeof value === 'string' &&
+        /^[a-zA-Z0-9_.]+::[a-zA-Z0-9_]+::("[^"]*"|[a-zA-Z0-9_]*|)$/.test(value));
+};
+/**
+ * Converts a string or boolean value to a boolean.
+ *
+ * String values are converted by checking if they equal the string "true".
+ * Boolean values are returned as-is.
+ *
+ * @param value - The value to convert (string or boolean)
+ * @returns The boolean representation of the value
+ *
+ * @example
+ * ```tsx
+ * toBool("true"); // true
+ * toBool("false"); // false
+ * toBool(true); // true
+ * toBool(false); // false
+ * toBool("yes"); // false
+ * ```
+ *
+ * @public
+ */
+export const toBool = (value) => {
+    if (typeof value === 'boolean')
+        return value;
+    return value === 'true';
+};
+/**
+ * Converts a string or boolean value to a number.
+ *
+ * - Boolean values: true becomes 1, false becomes 0
+ * - String values: parsed using Number(), returns 0 if NaN
+ *
+ * @param value - The value to convert (string or boolean)
+ * @returns The numeric representation of the value (0 if conversion fails)
+ *
+ * @example
+ * ```tsx
+ * toNumber("123"); // 123
+ * toNumber("45.67"); // 45.67
+ * toNumber(true); // 1
+ * toNumber(false); // 0
+ * toNumber("invalid"); // 0
+ * ```
+ *
+ * @public
+ */
+export const toNumber = (value) => {
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    const numValue = Number(value);
+    if (isNaN(numValue))
+        return 0;
+    return numValue;
+};
+export const parseJoin = (key) => {
+    return key.replace(/\n/g, '').split(';');
+};
+//# sourceMappingURL=utils.js.map

package/dist/state/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/state/utils.ts"],"names":[],"mappings":"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"}

package/dist/this.d.ts

@@ -0,0 +1,6 @@
+export type This = ['this', string?];
+export declare const isThis: (value?: string) => boolean;
+export declare const isDataThis: (value?: string) => boolean | undefined;
+export declare const parseDataThis: (value: string) => string[];
+export declare const parseThis: (value?: string) => This;
+//# sourceMappingURL=this.d.ts.map

package/dist/this.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"this.d.ts","sourceRoot":"","sources":["../src/this.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAErC,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,YAEpC,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,wBAExC,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,aAE1C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,IAE1C,CAAC"}

package/dist/this.js

@@ -0,0 +1,15 @@
+import { DATA_THIS, DOT_SEPARATOR, FN_SEPARATOR } from './constants';
+const actionThisRegExp = new RegExp(`^"this(${FN_SEPARATOR}\\d+)?"$`);
+export const isThis = (value) => {
+    return actionThisRegExp.test(value || '');
+};
+export const isDataThis = (value) => {
+    return value?.startsWith(DATA_THIS);
+};
+export const parseDataThis = (value) => {
+    return value.replace(DATA_THIS, '').split(DOT_SEPARATOR);
+};
+export const parseThis = (value) => {
+    return value ? value.slice(1, -1).split(FN_SEPARATOR) : ['this'];
+};
+//# sourceMappingURL=this.js.map

package/dist/this.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"this.js","sourceRoot":"","sources":["../src/this.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAErE,MAAM,gBAAgB,GAAG,IAAI,MAAM,CAAC,UAAU,YAAY,UAAU,CAAC,CAAC;AAItE,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAc,EAAE,EAAE;IACvC,OAAO,gBAAgB,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;AAC5C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAc,EAAE,EAAE;IAC3C,OAAO,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAa,EAAE,EAAE;IAC7C,OAAO,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;AAC3D,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAQ,EAAE;IAChD,OAAO,KAAK,CAAC,CAAC,CAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7E,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@mapples/inlang",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "author": {
+    "name": "Oleksandr Soloviov",
+    "url": "https://mapples.org/people/olek_soloviov"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mapplesorg/mapples-open-kit.git",
+    "directory": "packages/@mapples/inlang"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ]
+}