@mapples/types 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md ADDED
@@ -0,0 +1,454 @@
1
+ # @mapples/types
2
+
3
+ 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.
4
+
5
+ ## Installation
6
+
7
+ ```bash
8
+ npm install @mapples/types
9
+ # or
10
+ yarn add @mapples/types
11
+ ```
12
+
13
+ ## Overview
14
+
15
+ 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.
16
+
17
+ ## Core Types
18
+
19
+ ### Action Types
20
+
21
+ #### `Action`
22
+
23
+ Represents a user action that occurred in the application. Actions are used for tracking user interactions, analytics, and state management.
24
+
25
+ ```typescript
26
+ interface Action {
27
+ time: number; // Timestamp when the action occurred (in milliseconds since epoch)
28
+ type?: string; // Optional string identifier for the type of action
29
+ payload?: ActionPayload; // Optional payload containing additional data about the action
30
+ }
31
+ ```
32
+
33
+ #### `ActionPayload`
34
+
35
+ Represents the payload data that can be attached to an action.
36
+
37
+ ```typescript
38
+ interface ActionPayload {
39
+ originalEventData?: any[]; // Original event data from the source event
40
+ data?: any; // Custom data payload specific to the action
41
+ }
42
+ ```
43
+
44
+ **Example:**
45
+
46
+ ```typescript
47
+ import { Action, ActionPayload } from '@mapples/types';
48
+
49
+ const userAction: Action = {
50
+ time: Date.now(),
51
+ type: 'BUTTON_PRESSED',
52
+ payload: {
53
+ data: { buttonId: 'submit', userId: '123' },
54
+ originalEventData: ['button', 'press', { x: 100, y: 200 }],
55
+ },
56
+ };
57
+ ```
58
+
59
+ ### Mapplet Types
60
+
61
+ #### `MappletType<State>`
62
+
63
+ Represents the configuration interface for a Mapplet application. A Mapplet is a self-contained application that can be embedded or run standalone.
64
+
65
+ ```typescript
66
+ interface MappletType<State extends object = object> {
67
+ state?: State; // Optional initial state object for the Mapplet
68
+ onAction?: (action: Action) => void; // Optional callback function to handle actions
69
+ }
70
+ ```
71
+
72
+ **Example:**
73
+
74
+ ```typescript
75
+ import { MappletType, Action } from '@mapples/types';
76
+
77
+ interface MyAppState {
78
+ user: { name: string; email: string };
79
+ settings: { theme: string };
80
+ }
81
+
82
+ const myMapplet: MappletType<MyAppState> = {
83
+ state: {
84
+ user: { name: 'John', email: 'john@example.com' },
85
+ settings: { theme: 'dark' },
86
+ },
87
+ onAction: (action: Action) => {
88
+ console.log('Mapplet action:', action);
89
+ // Handle analytics, logging, etc.
90
+ },
91
+ };
92
+ ```
93
+
94
+ ### Asset Types
95
+
96
+ #### `AssetType`
97
+
98
+ Represents the different types of assets that can be used in the Mapples system.
99
+
100
+ ```typescript
101
+ type AssetType = 'image' | 'video' | 'icon' | 'font' | 'json';
102
+ ```
103
+
104
+ **Example:**
105
+
106
+ ```typescript
107
+ import { AssetType } from '@mapples/types';
108
+
109
+ const imageAsset: AssetType = 'image';
110
+ const videoAsset: AssetType = 'video';
111
+ ```
112
+
113
+ ### Component Types
114
+
115
+ #### `RegisteredComponent<T>`
116
+
117
+ 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.
118
+
119
+ ```typescript
120
+ interface RegisteredComponent<T extends object = object> {
121
+ type: string; // Unique component identifier
122
+ groupId: string; // Group this component belongs to
123
+ label: string; // Display name
124
+ Component: ComponentType<PropsWithChildren<T>>; // React component
125
+ Icon: ComponentType<SvgProps>; // Icon for component palette
126
+ initialProps: T; // Default props
127
+ styleKeys: StyleKey[]; // Available style properties
128
+ props: PropsFormField[]; // Property form fields
129
+ actionProps: string[]; // Action-triggering properties
130
+ hidden?: boolean; // Hide from palette
131
+ hasChildren?: boolean; // Can contain children
132
+ }
133
+ ```
134
+
135
+ **Example:**
136
+
137
+ ```typescript
138
+ import { RegisteredComponent } from '@mapples/types';
139
+
140
+ interface ButtonProps {
141
+ text: string;
142
+ disabled?: boolean;
143
+ onPress?: () => void;
144
+ }
145
+
146
+ const buttonComponent: RegisteredComponent<ButtonProps> = {
147
+ type: 'Button',
148
+ groupId: 'inputs',
149
+ label: 'Button',
150
+ Component: Button,
151
+ Icon: ButtonIcon,
152
+ initialProps: { text: 'Click me' },
153
+ styleKeys: [backgroundColorStyle, textColorStyle],
154
+ props: [textField, disabledField],
155
+ actionProps: ['onPress'],
156
+ };
157
+ ```
158
+
159
+ #### `RegisteredComponentsGroup`
160
+
161
+ Represents a group of components in the component palette.
162
+
163
+ ```typescript
164
+ interface RegisteredComponentsGroup {
165
+ id: string; // Unique group identifier
166
+ label: string; // Display name
167
+ Icon: ComponentType<SvgProps>; // Group icon
168
+ }
169
+ ```
170
+
171
+ #### `RegisteredComponents`
172
+
173
+ A registry mapping component types to their definitions.
174
+
175
+ ```typescript
176
+ type RegisteredComponents = Record<string, RegisteredComponent>;
177
+ ```
178
+
179
+ #### `StyleKey`
180
+
181
+ Defines a style property configuration.
182
+
183
+ ```typescript
184
+ interface StyleKey {
185
+ label: string; // Human-readable label
186
+ value: string; // CSS property name
187
+ forms: StyleFormType[]; // Applicable form types
188
+ }
189
+ ```
190
+
191
+ ### Form Types
192
+
193
+ #### `StyleFormType`
194
+
195
+ Enum representing different categories of style forms.
196
+
197
+ ```typescript
198
+ enum StyleFormType {
199
+ Dimension = 'Dimension', // Width, height, min/max dimensions
200
+ Image = 'Image', // Background images, object fit
201
+ Text = 'Text', // Text color, alignment
202
+ Typography = 'Typography', // Font family, size, weight
203
+ Position = 'Position', // Top, left, right, bottom
204
+ Surface = 'Surface', // Background color, opacity
205
+ ScrollSurface = 'ScrollSurface', // Scrollable surface properties
206
+ Borders = 'Borders', // Border width, color, radius
207
+ Shadow = 'Shadow', // Box shadow, elevation
208
+ Spacing = 'Spacing', // Margin, padding
209
+ Svg = 'Svg', // SVG-related properties
210
+ }
211
+ ```
212
+
213
+ #### `PropsFormType`
214
+
215
+ Enum for property form field types.
216
+
217
+ ```typescript
218
+ enum PropsFormType {
219
+ Text = 'Text', // Text input field
220
+ Select = 'Select', // Single selection dropdown
221
+ Switch = 'Switch', // Boolean toggle
222
+ MultiSelect = 'MultiSelect', // Multiple selection dropdown
223
+ }
224
+ ```
225
+
226
+ #### `PropsFormField`
227
+
228
+ Configuration for component property form fields.
229
+
230
+ ```typescript
231
+ interface PropsFormField {
232
+ propsKey: string; // Property key in component props
233
+ label: string; // Form field label
234
+ options?: PropsFormFieldOptions; // Options for select fields
235
+ type: PropsFormType; // Form field type
236
+ dataProp?: boolean; // Can be bound to data sources
237
+ }
238
+ ```
239
+
240
+ **Example:**
241
+
242
+ ```typescript
243
+ import { PropsFormField, PropsFormType } from '@mapples/types';
244
+
245
+ const textField: PropsFormField = {
246
+ propsKey: 'text',
247
+ label: 'Button Text',
248
+ type: PropsFormType.Text,
249
+ };
250
+
251
+ const sizeField: PropsFormField = {
252
+ propsKey: 'size',
253
+ label: 'Size',
254
+ type: PropsFormType.Select,
255
+ options: [
256
+ { label: 'Small', value: 'sm' },
257
+ { label: 'Medium', value: 'md' },
258
+ { label: 'Large', value: 'lg' },
259
+ ],
260
+ };
261
+ ```
262
+
263
+ #### `PropsFormFieldOption`
264
+
265
+ Represents an option in select/multi-select fields.
266
+
267
+ ```typescript
268
+ interface PropsFormFieldOption {
269
+ label: string; // Display text
270
+ value: string; // Stored value
271
+ }
272
+ ```
273
+
274
+ #### `PropsFormFieldOptions`
275
+
276
+ Union type for form field options.
277
+
278
+ ```typescript
279
+ type PropsFormFieldOptions =
280
+ | PropsFormFieldOption[] // Array of options
281
+ | 'typography' // Special typography type
282
+ | AssetType; // Asset type for asset selection
283
+ ```
284
+
285
+ #### `ActionFormProps`
286
+
287
+ Configuration for action properties.
288
+
289
+ ```typescript
290
+ interface ActionFormProps {
291
+ propsKey: string; // Action property key
292
+ label: string; // Form field label
293
+ }
294
+ ```
295
+
296
+ #### `PropsFieldConfig`
297
+
298
+ Mapping of form types to their React components.
299
+
300
+ ```typescript
301
+ type PropsFieldConfig = Record<PropsFormType, ComponentType<PropsFormField>>;
302
+ ```
303
+
304
+ ## Usage Examples
305
+
306
+ ### Registering a Component
307
+
308
+ ```typescript
309
+ import {
310
+ RegisteredComponent,
311
+ PropsFormField,
312
+ PropsFormType,
313
+ StyleFormType,
314
+ StyleKey,
315
+ } from '@mapples/types';
316
+
317
+ // Define component props
318
+ interface MyButtonProps {
319
+ text: string;
320
+ variant: 'primary' | 'secondary';
321
+ disabled?: boolean;
322
+ }
323
+
324
+ // Create style keys
325
+ const backgroundColorStyle: StyleKey = {
326
+ label: 'Background Color',
327
+ value: 'backgroundColor',
328
+ forms: [StyleFormType.Surface],
329
+ };
330
+
331
+ // Create form fields
332
+ const textField: PropsFormField = {
333
+ propsKey: 'text',
334
+ label: 'Button Text',
335
+ type: PropsFormType.Text,
336
+ };
337
+
338
+ const variantField: PropsFormField = {
339
+ propsKey: 'variant',
340
+ label: 'Variant',
341
+ type: PropsFormType.Select,
342
+ options: [
343
+ { label: 'Primary', value: 'primary' },
344
+ { label: 'Secondary', value: 'secondary' },
345
+ ],
346
+ };
347
+
348
+ // Register the component
349
+ const myButtonComponent: RegisteredComponent<MyButtonProps> = {
350
+ type: 'MyButton',
351
+ groupId: 'custom',
352
+ label: 'My Button',
353
+ Component: MyButton,
354
+ Icon: MyButtonIcon,
355
+ initialProps: {
356
+ text: 'Click me',
357
+ variant: 'primary',
358
+ },
359
+ styleKeys: [backgroundColorStyle],
360
+ props: [textField, variantField],
361
+ actionProps: ['onPress'],
362
+ };
363
+ ```
364
+
365
+ ### Creating a Component Group
366
+
367
+ ```typescript
368
+ import { RegisteredComponentsGroup } from '@mapples/types';
369
+
370
+ const customGroup: RegisteredComponentsGroup = {
371
+ id: 'custom',
372
+ label: 'Custom Components',
373
+ Icon: CustomIcon,
374
+ };
375
+ ```
376
+
377
+ ### Working with Form Fields
378
+
379
+ ```typescript
380
+ import {
381
+ PropsFormField,
382
+ PropsFormType,
383
+ PropsFormFieldOptions,
384
+ } from '@mapples/types';
385
+
386
+ // Text field
387
+ const nameField: PropsFormField = {
388
+ propsKey: 'name',
389
+ label: 'Name',
390
+ type: PropsFormType.Text,
391
+ };
392
+
393
+ // Select field with options
394
+ const statusField: PropsFormField = {
395
+ propsKey: 'status',
396
+ label: 'Status',
397
+ type: PropsFormType.Select,
398
+ options: [
399
+ { label: 'Active', value: 'active' },
400
+ { label: 'Inactive', value: 'inactive' },
401
+ { label: 'Pending', value: 'pending' },
402
+ ],
403
+ };
404
+
405
+ // Asset selection field
406
+ const imageField: PropsFormField = {
407
+ propsKey: 'image',
408
+ label: 'Image',
409
+ type: PropsFormType.Select,
410
+ options: 'image', // AssetType
411
+ };
412
+
413
+ // Typography field
414
+ const fontField: PropsFormField = {
415
+ propsKey: 'font',
416
+ label: 'Font',
417
+ type: PropsFormType.Select,
418
+ options: 'typography',
419
+ };
420
+ ```
421
+
422
+ ## Integration with Other Packages
423
+
424
+ This types package is used throughout the Mapples ecosystem:
425
+
426
+ - **@mapples/action**: Uses `Action` and `ActionPayload` types for action management
427
+ - **@mapples/state**: Uses state-related types for state management
428
+ - **@mapples/ui**: Uses `RegisteredComponent` and related types for component registration
429
+ - **@mapples/form**: Uses `PropsFormField` and form-related types for property editing
430
+ - **@mapples/style**: Uses `StyleKey` and `StyleFormType` for styling configuration
431
+ - **@mapples/render**: Uses component types for rendering components
432
+
433
+ ## Type Safety
434
+
435
+ All types in this package are designed to provide maximum type safety and IntelliSense support. When working with Mapples components, you'll get:
436
+
437
+ - Autocomplete for all properties
438
+ - Type checking for component props
439
+ - Validation for form field configurations
440
+ - IntelliSense for style properties
441
+
442
+ ## Contributing
443
+
444
+ When adding new types to this package:
445
+
446
+ 1. Follow the existing naming conventions
447
+ 2. Add comprehensive TSDoc comments
448
+ 3. Include usage examples
449
+ 4. Update this README with new types
450
+ 5. Ensure all types are exported from the main index file
451
+
452
+ ## License
453
+
454
+ MIT
@@ -0,0 +1,26 @@
1
+ /**
2
+ * Represents the payload data that can be attached to an action.
3
+ *
4
+ * @interface ActionPayload
5
+ */
6
+ export interface ActionPayload {
7
+ /** Original event data from the source event (e.g., touch events, form data) */
8
+ originalEventData?: any[];
9
+ /** Custom data payload specific to the action */
10
+ data?: any;
11
+ }
12
+ /**
13
+ * Represents a user action that occurred in the application.
14
+ * Actions are used for tracking user interactions, analytics, and state management.
15
+ *
16
+ * @interface Action
17
+ */
18
+ export interface Action {
19
+ /** Timestamp when the action occurred (in milliseconds since epoch) */
20
+ time: number;
21
+ /** Optional string identifier for the type of action (e.g., 'BUTTON_PRESSED', 'FORM_SUBMITTED') */
22
+ type?: string;
23
+ /** Optional payload containing additional data about the action */
24
+ payload?: ActionPayload;
25
+ }
26
+ //# sourceMappingURL=action.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,GAAG,EAAE,CAAC;IAC1B,iDAAiD;IACjD,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,mGAAmG;IACnG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB"}
package/dist/action.js ADDED
@@ -0,0 +1 @@
1
+ //# sourceMappingURL=action.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"action.js","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":""}
@@ -0,0 +1,56 @@
1
+ import { ComponentType, PropsWithChildren } from 'react';
2
+ /**
3
+ * Represents a registered component in the Mapples component system.
4
+ * This interface defines all the metadata and configuration needed to register
5
+ * a component for use in the visual editor.
6
+ *
7
+ * @interface RegisteredComponent
8
+ * @template T - The props type for the component (must extend object)
9
+ *
10
+ * @property {string} type - Unique identifier for the component type
11
+ * @property {ComponentType<PropsWithChildren<T>>} Component - The actual React component
12
+ *
13
+ * @example
14
+ * ```typescript
15
+ * const buttonComponent: RegisteredComponent<ButtonProps> = {
16
+ * type: 'Button',
17
+ * Component: Button,
18
+ * };
19
+ * ```
20
+ */
21
+ export interface RegisteredComponent<T extends object = object> {
22
+ type: string;
23
+ Component: ComponentType<PropsWithChildren<T>>;
24
+ }
25
+ /**
26
+ * A record type that maps component type strings to their registered component definitions.
27
+ * This is the main registry structure for all available components in the system.
28
+ *
29
+ * @type RegisteredComponents
30
+ * @example
31
+ * ```typescript
32
+ * const components: RegisteredComponents = {
33
+ * 'Button': buttonComponent,
34
+ * 'TextInput': textInputComponent,
35
+ * 'View': viewComponent
36
+ * };
37
+ * ```
38
+ */
39
+ export type RegisteredComponents = Record<string, RegisteredComponent>;
40
+ /**
41
+ * Configuration for data properties that can be bound to components.
42
+ *
43
+ * @interface DataProp
44
+ * @property {string} key - The key identifier for the data property
45
+ * @property {boolean} active - Whether this data property is currently active
46
+ */
47
+ export interface DataProp {
48
+ key: string;
49
+ active: boolean;
50
+ }
51
+ /**
52
+ * A map of data properties indexed by their names.
53
+ * Each entry contains configuration for binding data to components.
54
+ */
55
+ export type DataProps = Partial<Record<string, DataProp>>;
56
+ //# sourceMappingURL=components.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../src/components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC"}
@@ -0,0 +1 @@
1
+ //# sourceMappingURL=components.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"components.js","sourceRoot":"","sources":["../src/components.ts"],"names":[],"mappings":""}
@@ -0,0 +1,4 @@
1
+ export * from './components';
2
+ export * from './action';
3
+ export * from './mapplet';
4
+ //# sourceMappingURL=index.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
package/dist/index.js ADDED
@@ -0,0 +1,4 @@
1
+ export * from './components';
2
+ export * from './action';
3
+ export * from './mapplet';
4
+ //# sourceMappingURL=index.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
@@ -0,0 +1,37 @@
1
+ import { Action } from './action';
2
+ /**
3
+ * Represents the configuration interface for a Mapplet application.
4
+ * A Mapplet is a self-contained application that can be embedded or run standalone.
5
+ *
6
+ * @interface MappletType
7
+ * @template State - The type of the application state (must extend object)
8
+ *
9
+ * @property {State} [state] - Optional initial state object for the Mapplet
10
+ * @property {(action: Action) => void} [onAction] - Optional callback function to handle actions emitted by the Mapplet
11
+ *
12
+ * @example
13
+ * ```typescript
14
+ * interface MyAppState {
15
+ * user: { name: string; email: string };
16
+ * settings: { theme: string };
17
+ * }
18
+ *
19
+ * const myMapplet: MappletType<MyAppState> = {
20
+ * state: {
21
+ * user: { name: 'John', email: 'john@example.com' },
22
+ * settings: { theme: 'dark' }
23
+ * },
24
+ * onAction: (action) => {
25
+ * console.log('Mapplet action:', action);
26
+ * // Handle analytics, logging, etc.
27
+ * }
28
+ * };
29
+ * ```
30
+ */
31
+ export interface MappletType<State extends object = object> {
32
+ /** Optional initial state object for the Mapplet */
33
+ state?: State;
34
+ /** Optional callback function to handle actions emitted by the Mapplet */
35
+ onAction?: (action: Action) => void;
36
+ }
37
+ //# sourceMappingURL=mapplet.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"mapplet.d.ts","sourceRoot":"","sources":["../src/mapplet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACxD,oDAAoD;IACpD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC"}
@@ -0,0 +1 @@
1
+ //# sourceMappingURL=mapplet.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"mapplet.js","sourceRoot":"","sources":["../src/mapplet.ts"],"names":[],"mappings":""}
package/package.json ADDED
@@ -0,0 +1,35 @@
1
+ {
2
+ "name": "@mapples/types",
3
+ "version": "1.0.2",
4
+ "main": "dist/index.js",
5
+ "types": "dist/index.d.ts",
6
+ "scripts": {
7
+ "build": "tsc -b tsconfig.build.json",
8
+ "lint": "eslint .",
9
+ "type-check": "tsc --noEmit",
10
+ "clean": "rm -rf dist"
11
+ },
12
+ "author": {
13
+ "name": "Oleksandr Soloviov",
14
+ "url": "https://mapples.org/people/olek_soloviov"
15
+ },
16
+ "license": "MIT",
17
+ "repository": {
18
+ "type": "git",
19
+ "url": "https://github.com/mapplesorg/mapples-open-kit.git",
20
+ "directory": "packages/@mapples/types"
21
+ },
22
+ "peerDependencies": {
23
+ "react": ">=18.0.0 <20.0.0",
24
+ "react-native": ">=0.71.0"
25
+ },
26
+ "devDependencies": {
27
+ "@types/react": ">=18.0.0 <20.0.0",
28
+ "typescript": "~5.9.2"
29
+ },
30
+ "files": [
31
+ "dist",
32
+ "README.md",
33
+ "package.json"
34
+ ]
35
+ }