@luna-park/plugin 1.5.1 → 1.7.0

package/dist/{dist-Cnje_ZD3.mjs → dist-BoFOku7q.mjs}

@@ -596,6 +596,7 @@ function schemaLoop(schema, func, key) {
 	}) || schema;
 	if (schema.type === "object") for (const key in schema.properties) schema.properties[key] = schemaLoop(schema.properties[key], func, key);
 	if (schema.type === "array") schema.items = schemaLoop(schema.items, func);
+	if (schema.type === "record") schema.value = schemaLoop(schema.value, func);
 	if (schema.type === "function") {
 		schema.inputs = schemaLoop(schema.inputs, func);
 		schema.output = schemaLoop(schema.output, func);

package/dist/eslint.d.mts

@@ -0,0 +1,21 @@
+//#region src/eslint/index.d.ts
+export declare const objectKeysOptions: {
+  orderedKeys: string[];
+  selectors: {
+    target: {
+      name: string;
+      type: "function" | "property";
+    };
+    mode: "direct" | "recursive";
+    orderedKeys?: Array<string>;
+    sorting?: "asc" | "desc" | "none";
+  }[];
+};
+declare const _default: {
+  name: string;
+  rules: {
+    "sort-keys-custom-order/object-keys": ["error", typeof objectKeysOptions];
+  };
+};
+//#endregion
+export { _default as default };

package/dist/eslint.mjs

@@ -0,0 +1,73 @@
+//#region src/eslint/index.ts
+function selector(name, type, options) {
+	return {
+		mode: "direct",
+		...options,
+		target: {
+			name,
+			type
+		}
+	};
+}
+const objectKeysOptions = {
+	orderedKeys: ["id", "name"],
+	selectors: [
+		selector("makePlugin", "function", { orderedKeys: [
+			"id",
+			"name",
+			"description",
+			"icon",
+			"color",
+			"llm",
+			"config",
+			"internals",
+			"settings",
+			"lifecycle",
+			"editor",
+			"hooks",
+			"windows",
+			"inject",
+			"build"
+		] }),
+		selector("lifecycle", "property", { orderedKeys: [
+			"mount",
+			"update",
+			"unmount"
+		] }),
+		selector("editor", "property", { orderedKeys: [
+			"components",
+			"nodes",
+			"tokens",
+			"panel",
+			"inputs",
+			"interfaces",
+			"guards",
+			"templates",
+			"wrapper"
+		] }),
+		selector("documentation", "property", { orderedKeys: ["short", "description"] }),
+		selector("schema", "property", {
+			mode: "recursive",
+			sorting: "none"
+		}),
+		selector("makeLogicNode", "function", { orderedKeys: [
+			"name",
+			"inputs",
+			"outputs",
+			"config",
+			"methods",
+			"display",
+			"documentation",
+			"build"
+		] }),
+		selector("inputs", "property", { sorting: "none" }),
+		selector("outputs", "property", { sorting: "none" }),
+		selector("methods", "property", { sorting: "none" })
+	]
+};
+var eslint_default = {
+	name: "@luna-park/plugin/eslint",
+	rules: { "sort-keys-custom-order/object-keys": ["error", objectKeysOptions] }
+};
+//#endregion
+export { eslint_default as default, objectKeysOptions };

package/dist/extractor.d.mts

@@ -1,4 +1,4 @@
-import { l as TSchema } from "./index-DQhxmFHB.mjs";
+import { d as TSchema } from "./index-76yMHag4.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
 //#region src/extractor/export/type.d.ts

package/dist/extractor.mjs

@@ -1,4 +1,4 @@
-import { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-Cnje_ZD3.mjs";
+import { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-BoFOku7q.mjs";
 import fs from "node:fs";
 import * as ts$1 from "typescript";
 import ts from "typescript";

package/dist/{index-DQhxmFHB.d.mts → index-76yMHag4.d.mts}

@@ -111,7 +111,8 @@ interface TObject<T extends TProperties = TProperties> {
   static: StaticObject<T>;
   type: EVarType.object;
 }
-interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
+type TRecordKey = TString | TNumber;
+interface TRecord<TKey extends TRecordKey = TString, TValue extends TSchema = TSchema> {
   key: TKey;
   static: StaticRecord<TKey, TValue>;
   type: EVarType.record;
@@ -144,7 +145,7 @@ type TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSch
   static: StaticFunction<TParameters, TOutput, TPromise>;
   type: EVarType.function;
 };
-type TAnyLogic = TExec | TObject | TRecord<TString | TNumber> | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TFunction<TObject, TSchema, boolean, ReadonlyArray<never>> | TVoid;
+type TAnyLogic = TExec | TObject | TRecord<TRecordKey> | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TFunction<TObject, TSchema, boolean, ReadonlyArray<never>> | TVoid;
 type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TLogic & TArguments;
 declare const LogicType: {
   array: <T extends TSchema, TArgs extends TArguments<Array<StaticSchema<T>>>>(items: T, args?: TArgs) => TArray<T> & TArgs;
@@ -154,7 +155,7 @@ declare const LogicType: {
   interface: <T = unknown, TArgs extends TArguments<T> = TArguments<T>>(interfaceClass: (new (...args: Array<unknown>) => T) | string, args?: TArgs) => TInterface<T> & TArgs;
   number: <TArgs extends TArguments<number>>(args?: TArgs) => TNumber & TArgs;
   object: <T extends TProperties, TArgs extends TArguments<object>>(properties?: T, args?: TArgs) => TObject<T> & TArgs;
-  record: <TKey extends TString | TNumber, TValue extends TSchema, const TArgs extends TArguments<StaticRecord<TKey, TValue>> = {}>(key: TKey, value: TValue, args?: TArgs) => TRecord<TKey, TValue> & TArgs;
+  record: <TKey extends TRecordKey, TValue extends TSchema, const TArgs extends TArguments<StaticRecord<TKey, TValue>> = {}>(key: TKey, value: TValue, args?: TArgs) => TRecord<TKey, TValue> & TArgs;
   string: <TArgs extends TArguments<string>>(args?: TArgs) => TString & TArgs;
   type: typeof createType;
   undefined: <const TArgs extends TArguments<undefined> = {}>(args?: TArgs) => TUndefined & TArgs;
@@ -170,7 +171,7 @@ type StaticSchema<T extends TSchema> = [TSchema] extends [T] ? unknown : T exten
   static: unknown;
 } ? Static<T> : unknown;
 type StaticObject<T extends TProperties> = string extends keyof T ? Record<string, unknown> : { [K in RequiredKeys<T>]: StaticSchema<T[K]>; } & { [K in OptionalKeys<T>]?: StaticSchema<T[K]>; };
-type StaticRecord<TKey extends TSchema<TString> | TSchema<TNumber>, TValue extends TSchema> = Record<StaticSchema<TKey> & (string | number), StaticSchema<TValue>>;
+type StaticRecord<TKey extends TSchema<TRecordKey>, TValue extends TSchema> = Record<StaticSchema<TKey> & (string | number), StaticSchema<TValue>>;
 type StaticUnion<T extends ReadonlyArray<TSchema>> = StaticSchema<T[number]>;
 type TStaticParameters<T extends ReadonlyArray<TSchema>> = number extends T["length"] ? Array<StaticSchema<T[number]>> : T extends readonly [...infer TRest extends ReadonlyArray<TSchema>, infer TLast extends TSchema] ? TLast extends {
   optional: true;
@@ -212,6 +213,28 @@ declare const LogicUtil: {
   required<TTarget extends TObject>(target: TTarget): TTransformedObject<TTarget, TRequiredProperties<TTarget["properties"]>>;
 };
 //#endregion
+//#region src/logic/interface.d.ts
+type TInterfaceConstantValue = string | number | boolean | object;
+type TInterfaceConstantConfig<TEditor = unknown> = {
+  build?: {
+    generate?: (code: string) => string;
+    imports?: Array<{
+      name: string;
+      target: string;
+    }>;
+  };
+  editor?: TEditor;
+  parse?: (value: TInterfaceConstantValue) => unknown;
+  schema?: TSchema;
+  serialize?: (instance: unknown) => TInterfaceConstantValue;
+};
+type TInterfaceConfig<TEditor = unknown> = {
+  class?: new (...args: Array<unknown>) => unknown;
+  constant?: TInterfaceConstantConfig<TEditor>;
+  extends?: Array<string>;
+  name: string;
+};
+//#endregion
 //#region src/logic/node.d.ts
 type Component = {
   name: string;
@@ -234,13 +257,14 @@ type TNodeDisplay = {
     back?: string | IconDefinition;
     data?: {
       size?: {
-        x: number;
-        y: number;
+        x?: number;
+        y?: number;
       };
     };
     fixed?: boolean;
     headerless?: boolean;
     hoverable?: boolean;
+    hue?: number;
     icon?: string | IconDefinition;
     inspector?: string;
     interfaceBelow?: boolean;
@@ -257,6 +281,7 @@ type TNodeDisplay = {
   inspector?: string;
   interface?: Component | string;
   name?: string;
+  onDoubleClick?: () => void | Promise<void>;
   priority?: number;
 };
 type TNodeConfigDescriptor = Record<string, TSchema>;
@@ -300,6 +325,7 @@ type TDocumentation = {
     description: string;
     name: string;
   }>;
+  short?: string;
 };
 type TOnlyExecOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? TAnchor : never]: TNodeInterfaceDescriptor[TAnchor]; };
 type TOnlyVarsOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? never : TAnchor]: TNodeInterfaceDescriptor[TAnchor]; };
@@ -398,4 +424,4 @@ type TLogicNode = {
 };
 declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode;
 //#endregion
-export { LogicUtil as a, TObject as c, makeLogicNode as d, CVector as f, TVector as h, LogicType as i, TSchema as l, MaybePromise as m, ELogicType as n, Static as o, DeepPartial as p, EVarType as r, TLogicNode as s, ELogicScope as t, TVoid as u };
+export { TVector as _, LogicUtil as a, TInterfaceConstantValue as c, TSchema as d, TVoid as f, MaybePromise as g, DeepPartial as h, LogicType as i, TLogicNode as l, CVector as m, ELogicType as n, Static as o, makeLogicNode as p, EVarType as r, TInterfaceConfig as s, ELogicScope as t, TObject as u };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { a as LogicUtil, c as TObject, d as makeLogicNode, f as CVector, h as TVector, i as LogicType, l as TSchema, m as MaybePromise, n as ELogicType, o as Static, p as DeepPartial, r as EVarType, s as TLogicNode, t as ELogicScope, u as TVoid } from "./index-DQhxmFHB.mjs";
+import { _ as TVector, a as LogicUtil, c as TInterfaceConstantValue, d as TSchema, f as TVoid, g as MaybePromise, h as DeepPartial, i as LogicType, l as TLogicNode, m as CVector, n as ELogicType, o as Static, p as makeLogicNode, r as EVarType, s as TInterfaceConfig, t as ELogicScope, u as TObject } from "./index-76yMHag4.mjs";
 import "typescript";
-import { Component, ComputedRef } from "vue";
+import { Component, ComputedRef, Directive } from "vue";
 import "@sinclair/typebox";
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
 import { Cron } from "lite-cron";
@@ -113,6 +113,23 @@ type THookParams = {
   };
 };
 //#endregion
+//#region src/types/interface.d.ts
+type TInterface = TInterfaceConfig<Component> & {
+  arguments?: Array<TSchema>;
+  description?: string;
+  methods?: Array<{
+    name: string;
+    parameters?: Array<TSchema>;
+    return: TSchema;
+  }>;
+};
+type TInterfaceEditorProps = {
+  anchor?: boolean;
+  modelValue?: TInterfaceConstantValue;
+  placeholder?: string;
+  schema: TSchema;
+};
+//#endregion
 //#region ../logic-dts/dist/nodes.d.ts
 type TExportNodeFunction = {
   name?: string;
@@ -129,7 +146,7 @@ type TExportNodeResult = {
   types: Record<string, TSchema>;
 };
 //#endregion
-//#region ../shared/dist/index-D4yemxKH.d.mts
+//#region ../shared/dist/index-BWE-Rute.d.mts
 //#endregion
 //#region src/types/editor/wire.d.ts
 declare class CPathPoint {
@@ -158,7 +175,7 @@ declare class CWire {
   get type(): TSchema;
   get toType(): TSchema;
   getPoints(): string;
-  registerRibbon(path: TPath): void;
+  getPath(): TPath;
 }
 type TWire<TExport extends boolean = false> = TExport extends true ? {
   from: {
@@ -401,6 +418,7 @@ type TLayoutSchema<TElement extends ELayoutElement = ELayoutElement, TExport ext
   element: TInnerElement;
   events: Record<string, Record<string, TLayoutEventParameter<TExport>>>;
   models?: Record<string, Array<string>>;
+  plugins?: Record<string, Record<string, TMaybeDynamicVariable<TExport>>>;
   properties: Record<string, TMaybeDynamicVariable<TExport>>;
   style: TLayoutStyle<TExport>;
   tag?: string;
@@ -466,8 +484,11 @@ type TApplicationConfig = {
   };
   description?: string;
   desktop: {
+    appleTeamId?: string;
+    backendUrl?: string;
     fullscreen: boolean;
     height: number;
+    identifier?: string;
     resizable: boolean;
     version: string;
     width: number;
@@ -505,8 +526,29 @@ type TApplicationConfig = {
   web: {
     history: EHistoryMode;
     pwa: boolean;
+    pwaConfig?: TApplicationPwaConfig;
   };
 };
+declare enum EPwaDisplay {
+  Standalone = "standalone",
+  Fullscreen = "fullscreen",
+  MinimalUi = "minimal-ui",
+  Browser = "browser"
+}
+declare enum EPwaOrientation {
+  Any = "any",
+  Portrait = "portrait",
+  Landscape = "landscape"
+}
+type TApplicationPwaConfig = {
+  backgroundColor: string;
+  description: string;
+  display: EPwaDisplay;
+  icon: string;
+  orientation: EPwaOrientation;
+  shortName: string;
+  themeColor: string;
+};
 type TFile<TExport extends boolean = false> = TFolder<TExport> | TFileComponent<TExport> | TFileConfig<TExport> | TFileCron<TExport> | TFileDatabase<TExport> | TFileRoute<TExport> | TFileScript<TExport> | TFileStore<TExport> | TFileText<TExport> | TFileType<TExport> | TFileMedia<TExport>;
 //#endregion
 //#region src/types/files/folder.d.ts
@@ -639,7 +681,7 @@ type TNodeData = {
     number: number;
   };
   optionals?: Record<string, boolean>;
-  size?: TVector;
+  size?: Partial<TVector>;
 } & Record<string, unknown>;
 declare class CNode {
   id: string;
@@ -676,6 +718,7 @@ declare class CNode {
   getRelativeAnchorLocation(anchor: CNodeAnchor): CVector;
   getRelativeAnchorLocation_internal(anchor: CNodeAnchor): CVector;
   getLocation(): CVector;
+  getHeaderHeight(): number;
   getSize(): TVector;
   execute(outputKey: string, stack?: TStack): MaybePromise<void>;
   get isAsync(): boolean;
@@ -913,16 +956,38 @@ type TValue<TExport extends boolean = false> = TExport extends false ? {
   schema: TSchema;
 } : TSchema;
 //#endregion
-//#region src/types/interface.d.ts
-type TInterface = {
-  arguments?: Array<TSchema>;
-  class?: new (...args: Array<unknown>) => unknown;
-  methods?: Array<{
-    name: string;
-    parameters?: Array<TSchema>;
-    return: TSchema;
-  }>;
-  name: string;
+//#region src/types/panel.d.ts
+type TElementPanelAction = {
+  icon: IconDefinition;
+  onClick: (params: {
+    getElements: () => Array<HTMLElement>;
+    schema: TLayoutSchema;
+  }) => void;
+  title: string;
+};
+type TElementPanel = {
+  actions?: Array<TElementPanelAction>;
+  component?: Component;
+  directive?: {
+    build: {
+      from: string;
+      name: `v${string}`;
+    };
+    value: Directive;
+  };
+  filter?: (schema: TLayoutSchema) => boolean;
+  icon?: IconDefinition;
+  id: string;
+  label: string;
+  properties?: Record<string, TSchema>;
+};
+type TElementPanelProps<TValues = Record<string, unknown>> = {
+  getElements: () => Array<HTMLElement>;
+  modelValue: TValues;
+  schema: TLayoutSchema;
+};
+type TPanels = {
+  element?: Array<TElementPanel>;
 };
 //#endregion
 //#region src/types/template.d.ts
@@ -986,6 +1051,7 @@ type TBasePlugin<TConfig extends TSchema = TSchema, TInternals = unknown> = {
     inputs?: Record<string, Component>;
     interfaces?: Array<TInterface>;
     nodes?: Array<TLogicNode>;
+    panel?: TPanels;
     templates?: Array<TTemplate>;
     tokens?: Array<TToken>;
     wrapper?: TComponent & {
@@ -1042,4 +1108,4 @@ export declare function makeComponent<TProps extends Record<string, TSchema>>(co
 export declare function loadPlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>, env: Partial<TEnv>): Promise<TBasePlugin<TConfig, TInternal>>;
 export declare function getPluginParam<T>(target: TOption<TEnv, T>, env: Partial<TEnv>): Promise<T>;
 //#endregion
-export { EElementType, ELogicScope, ELogicType, EVarType, _default as LSettingsStoryWrapper, LogicType, LogicUtil, type Static, type TAnyLogic, type TApplication, type TBasePlugin, type TComponent, type TDatabaseCondition, type TEnv, type TFile, type TFileComponent, type TFileConfig, type TFileCron, type TFileDatabase, type TFileMedia, type TFileRoute, type TFileScript, type TFileStore, type TFileText, type TFileType, type TFolder, type THookParams, type TLogic, type TLogicMain, type TLogicNode, type TOption, type TPlugin, type TProxyPlugin, type TRouteGuard, type TSchema, type TSlot, type TTemplate, type TToken, makeLogicNode };
+export { EElementType, ELogicScope, ELogicType, EVarType, _default as LSettingsStoryWrapper, LogicType, LogicUtil, type Static, type TAnyLogic, type TApplication, type TBasePlugin, type TComponent, type TDatabaseCondition, type TElementPanel, type TElementPanelAction, type TElementPanelProps, type TEnv, type TFile, type TFileComponent, type TFileConfig, type TFileCron, type TFileDatabase, type TFileMedia, type TFileRoute, type TFileScript, type TFileStore, type TFileText, type TFileType, type TFolder, type THookParams, type TInterface, type TInterfaceEditorProps, type TLayoutSchema, type TLogic, type TLogicMain, type TLogicNode, type TOption, type TPanels, type TPlugin, type TProxyPlugin, type TRouteGuard, type TSchema, type TSlot, type TTemplate, type TToken, makeLogicNode };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as LogicUtil, i as LogicType, n as ELogicType, o as makeLogicNode, r as EVarType, t as ELogicScope, u as cloneWithFunctions } from "./dist-Cnje_ZD3.mjs";
+import { a as LogicUtil, i as LogicType, n as ELogicType, o as makeLogicNode, r as EVarType, t as ELogicScope, u as cloneWithFunctions } from "./dist-BoFOku7q.mjs";
 import { createElementBlock, openBlock, renderSlot } from "vue";
 import { Type } from "@sinclair/typebox";
 //#region \0/plugin-vue/export-helper
@@ -185,9 +185,7 @@ let EPlanKey = /* @__PURE__ */ function(EPlanKey) {
 const flags = {
 	free: {
 		compilation: {
-			desktop: false,
 			export: true,
-			mobile: false,
 			source: false,
 			web: true
 		},
@@ -195,13 +193,15 @@ const flags = {
 			desktop: false,
 			web: true
 		},
+		desktop: { compilation: {
+			desktop: false,
+			mobile: false
+		} },
 		watermark: true
 	},
 	pro: {
 		compilation: {
-			desktop: true,
 			export: true,
-			mobile: true,
 			source: true,
 			web: true
 		},
@@ -209,6 +209,10 @@ const flags = {
 			desktop: true,
 			web: true
 		},
+		desktop: { compilation: {
+			desktop: true,
+			mobile: true
+		} },
 		watermark: false
 	}
 };
@@ -217,6 +221,10 @@ const user = Type.Object({
 	id: Type.Optional(Type.String()),
 	auth: Type.Optional(Type.Object({})),
 	mail: Type.String(),
+	terms: Type.Optional(Type.Object({
+		version: Type.Union([Type.String(), Type.Null()]),
+		acceptedAt: Type.Union([Type.String(), Type.Null()])
+	})),
 	plan: Type.Object({ name: Type.Enum(EPlanKey) }),
 	profile: Type.Object({
 		other: Type.Object({
@@ -385,19 +393,11 @@ const build = {
 };
 const compile$1 = {
 	type: "post",
-	body: Type.Object({
-		platform: Type.Optional(Type.Union([
-			Type.Literal("win32"),
-			Type.Literal("darwin"),
-			Type.Literal("linux")
-		])),
-		target: Type.Union([
-			Type.Literal("source"),
-			Type.Literal("export"),
-			Type.Literal("web"),
-			Type.Literal("desktop")
-		])
-	}),
+	body: Type.Object({ target: Type.Union([
+		Type.Literal("source"),
+		Type.Literal("export"),
+		Type.Literal("web")
+	]) }),
 	params: Type.Object({ id: Type.String() }),
 	response: { 200: Type.Object({
 		message: Type.String(),
@@ -409,22 +409,10 @@ const download = {
 	type: "get",
 	params: Type.Object({
 		id: Type.String(),
-		platform: Type.Optional(Type.Union([
-			Type.Literal("win32-installer"),
-			Type.Literal("darwin-installer"),
-			Type.Literal("linux-installer"),
-			Type.Literal("win32-portable"),
-			Type.Literal("darwin-portable"),
-			Type.Literal("linux-portable")
-		])),
-		target: Type.Union([
-			Type.Literal("source"),
-			Type.Literal("export"),
-			Type.Literal("desktop")
-		])
+		target: Type.Union([Type.Literal("source"), Type.Literal("export")])
 	}),
 	response: { 200: Type.Unknown() },
-	url: "/compiler/download/:id/:target/:platform?"
+	url: "/compiler/download/:id/:target"
 };
 var desktop_exports = /* @__PURE__ */ __exportAll({ latest: () => latest });
 const latest = {
@@ -811,6 +799,7 @@ const tick = {
 	url: "/turnstile/tick"
 };
 var user_exports = /* @__PURE__ */ __exportAll({
+	acceptTerms: () => acceptTerms,
 	confirmAccountDeletion: () => confirmAccountDeletion,
 	disconnect: () => disconnect,
 	get: () => get,
@@ -833,6 +822,12 @@ const get = {
 	response: { 200: types.user },
 	url: "/user"
 };
+const acceptTerms = {
+	type: "post",
+	body: Type.Object({ termsVersion: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/terms/accept"
+};
 const update = {
 	type: "post",
 	body: Type.Partial(types.user),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luna-park/plugin",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "private": false,
   "description": "Plugin helper for Luna Park.",
   "homepage": "https://luna-park.app",
@@ -18,6 +18,10 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
+    "./eslint": {
+      "types": "./dist/eslint.d.mts",
+      "import": "./dist/eslint.mjs"
+    },
     "./extractor": {
       "types": "./dist/extractor.d.mts",
       "import": "./dist/extractor.mjs"