@luna-park/plugin 1.5.0 → 1.6.0

package/bin/preview.js

@@ -1,50 +1,50 @@
-#!/usr/bin/env node
-import { parseArgs } from "node:util";
-
-import { resolve } from "path";
-
-import { startPreviewServer } from "../dist/preview.mjs";
-
-const cwd = process.cwd();
-
-// Parse CLI arguments
-const { values } = parseArgs({
-    options: {
-        dist: {
-            default: "dist",
-            short: "d",
-            type: "string"
-        },
-        help: {
-            default: false,
-            short: "h",
-            type: "boolean"
-        },
-        port: {
-            default: "2084",
-            short: "p",
-            type: "string"
-        }
-    }
-});
-
-if (values.help) {
-    console.log(`
-Usage: luna-preview [options]
-
-Options:
-  -p, --port <port>    Port to run the server on (default: 2084)
-  -d, --dist <dir>     Distribution directory to serve (default: dist)
-  -h, --help           Show this help message
-  `);
-    process.exit(0);
-}
-
-const dist = resolve(cwd, values.dist);
-const port = parseInt(values.port);
-
-startPreviewServer({
-    dist,
-    externals: ["vue", "vue-router", "@luna-park/design"],
-    port
-});
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+
+import { resolve } from "path";
+
+import { startPreviewServer } from "../dist/preview.mjs";
+
+const cwd = process.cwd();
+
+// Parse CLI arguments
+const { values } = parseArgs({
+    options: {
+        dist: {
+            default: "dist",
+            short: "d",
+            type: "string"
+        },
+        help: {
+            default: false,
+            short: "h",
+            type: "boolean"
+        },
+        port: {
+            default: "2084",
+            short: "p",
+            type: "string"
+        }
+    }
+});
+
+if (values.help) {
+    console.log(`
+Usage: luna-preview [options]
+
+Options:
+  -p, --port <port>    Port to run the server on (default: 2084)
+  -d, --dist <dir>     Distribution directory to serve (default: dist)
+  -h, --help           Show this help message
+  `);
+    process.exit(0);
+}
+
+const dist = resolve(cwd, values.dist);
+const port = parseInt(values.port);
+
+startPreviewServer({
+    dist,
+    externals: ["vue", "vue-router", "@luna-park/design"],
+    port
+});

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

@@ -448,6 +448,11 @@ function cleanUnion(schema) {
 }
 function cleanInterface(schema) {
 	if (schema.className === "Array") return LogicType.array(schema.options.template[0]);
+	if (schema.className === "Type" && schema.options?.template?.[0]?.enum?.length) {
+		const reference = schema.options.template[0].enum[0];
+		const target = (Array.isArray(reference) ? reference.join("") : String(reference)).split("/");
+		return LogicType.type(target, schema.optional ? { optional: true } : {});
+	}
 	if (schema.className === "keyof") return LogicType.string();
 	if (schema.className === "Record") return LogicType.object({});
 	if (schema.className === "PropertyKey") return LogicType.union([LogicType.string(), LogicType.number()]);
@@ -591,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/extractor.d.mts

@@ -1,4 +1,4 @@
-import { l as TSchema } from "./index-DwEOlEBY.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-JzydDdZn.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-DwEOlEBY.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,15 +257,17 @@ 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;
     noDelete?: boolean;
     noSelection?: boolean;
     notFound?: boolean;
@@ -256,6 +281,7 @@ type TNodeDisplay = {
   inspector?: string;
   interface?: Component | string;
   name?: string;
+  onDoubleClick?: () => void | Promise<void>;
   priority?: number;
 };
 type TNodeConfigDescriptor = Record<string, TSchema>;
@@ -284,6 +310,7 @@ type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TN
 };
 type TDocumentation = {
   description?: string;
+  dynamics?: string;
   examples?: Array<{
     inputs: Array<{
       key: string;
@@ -298,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]; };
@@ -396,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-DwEOlEBY.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";
@@ -78,9 +78,29 @@ type TRouteGuard = {
 //#region src/types/hooks.d.ts
 export declare enum EPluginHooks {
   BackendMiddleware = "backend/middleware",
-  BackendInputNode = "backend/input-node"
+  BackendInputNode = "backend/input-node",
+  DatabaseScope = "database/scope",
+  DatabaseChange = "database/change"
 }
+type TDatabaseCondition = {
+  operation: string;
+  source: Array<string>;
+  target: unknown;
+  type: "value" | "column";
+} | {
+  conditions: Array<TDatabaseCondition>;
+  type: "and" | "or";
+};
 type THookParams = {
+  [EPluginHooks.DatabaseScope]: {
+    addConditions: (conditions: Array<TDatabaseCondition>) => void;
+    table: string;
+  };
+  [EPluginHooks.DatabaseChange]: {
+    operation: "insert" | "update" | "delete";
+    rows: Array<Record<string, unknown>>;
+    table: string;
+  };
   [EPluginHooks.BackendMiddleware]: {
     cookies: Record<string, {
       options?: Record<string, unknown>;
@@ -93,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;
@@ -109,7 +146,7 @@ type TExportNodeResult = {
   types: Record<string, TSchema>;
 };
 //#endregion
-//#region ../shared/dist/index-DloGTzVR.d.mts
+//#region ../shared/dist/index-BWE-Rute.d.mts
 //#endregion
 //#region src/types/editor/wire.d.ts
 declare class CPathPoint {
@@ -138,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: {
@@ -284,7 +321,6 @@ type TRouteGuardRef = {
 };
 type TFileRoute<TExport extends boolean = false> = TFileBase<TExport> & {
   type: EElementType.Route;
-  dev?: boolean;
   guards?: Array<TRouteGuardRef>;
   input: {
     body: TSchema;
@@ -330,19 +366,6 @@ type TFileStore<TExport extends boolean = false> = TFileBase<TExport> & {
   value: Record<string, unknown>;
 }>;
 //#endregion
-//#region src/layout/template.d.ts
-declare enum EElementTemplate {
-  If = "if",
-  For = "for"
-}
-declare enum ETemplatePreview {
-  Display = "display",
-  Hide = "hide",
-  Real = "real",
-  Once = "once",
-  All = "all"
-}
-//#endregion
 //#region src/types/layout.d.ts
 type TTextBlock = {
   content: string;
@@ -359,10 +382,6 @@ type TLayoutContentType<TElement extends ELayoutElement, TExport extends boolean
 } : TElement extends ELayoutElement.customHtml ? {
   html: string;
   variables: Array<string>;
-} : TElement extends ELayoutElement.template ? {
-  preview: ETemplatePreview;
-  template: EElementTemplate;
-  var: TMaybeDynamicVariable<TExport>;
 } : TElement extends ELayoutElement.package ? {
   slots: Record<string, TLayoutSchema<ELayoutElement, TExport>>;
   target: Array<string>;
@@ -380,6 +399,11 @@ type TLayoutStyle<TExport extends boolean = false> = {
   quick?: Array<string>;
   [media: `${number}`]: TLayoutStyleStates<TExport> | undefined;
 };
+type TLayoutClass<TExport extends boolean = false> = {
+  id: string;
+  name: string;
+  style: TLayoutStyle<TExport>;
+};
 type TLayoutEventParameter<TExport extends boolean = false> = {
   schema: TSchema;
   value: TMaybeDynamicVariable<TExport>;
@@ -393,7 +417,8 @@ type TLayoutSchema<TElement extends ELayoutElement = ELayoutElement, TExport ext
   content: TLayoutContentType<TInnerElement, TExport>;
   element: TInnerElement;
   events: Record<string, Record<string, TLayoutEventParameter<TExport>>>;
-  model?: Array<string>;
+  models?: Record<string, Array<string>>;
+  plugins?: Record<string, Record<string, TMaybeDynamicVariable<TExport>>>;
   properties: Record<string, TMaybeDynamicVariable<TExport>>;
   style: TLayoutStyle<TExport>;
   tag?: string;
@@ -459,8 +484,11 @@ type TApplicationConfig = {
   };
   description?: string;
   desktop: {
+    appleTeamId?: string;
+    backendUrl?: string;
     fullscreen: boolean;
     height: number;
+    identifier?: string;
     resizable: boolean;
     version: string;
     width: number;
@@ -498,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
@@ -578,6 +627,7 @@ type TCanvas = {
   zoom: number;
 };
 type TGraph<TExport extends boolean = false> = {
+  autoplace?: boolean;
   canvas: TCanvas;
   nodes: Record<string, TNode<TExport>>;
   wires: Record<string, TWire<TExport>>;
@@ -631,7 +681,7 @@ type TNodeData = {
     number: number;
   };
   optionals?: Record<string, boolean>;
-  size?: TVector;
+  size?: Partial<TVector>;
 } & Record<string, unknown>;
 declare class CNode {
   id: string;
@@ -668,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;
@@ -808,6 +859,7 @@ type TComponentOptions = {
 };
 type TFileComponent<TExport extends boolean = false> = TFileBase<TExport> & {
   type: EElementType.Component;
+  classes?: Record<string, TLayoutClass<TExport>>;
   collapsed?: boolean;
   layout: TLayoutSchema<ELayoutElement, TExport>;
   logics: Record<string, TAnyLogic<TExport>>;
@@ -829,39 +881,40 @@ declare enum EDynamicVariableType {
   Dynamic = "dynamic",
   Token = "token"
 }
-declare enum EDynamicVariableOperation {
-  Identity = "identity",
+declare enum EDynamicOperation {
   Equal = "equal",
   NotEqual = "not-equal",
   Greater = "greater",
-  Less = "less",
   GreaterEqual = "greater-equal",
+  Less = "less",
   LessEqual = "less-equal",
   StartsWith = "starts-with",
   EndsWith = "ends-with",
   Includes = "includes",
-  Ternary = "ternary",
-  Cast = "cast",
   At = "at",
-  Join = "join"
-}
-declare enum EDynamicVariableChain {
+  Join = "join",
+  ToLowerCase = "to-lower-case",
+  Length = "length",
+  Not = "not",
+  And = "and",
+  Or = "or",
   Add = "add",
   Subtract = "subtract",
   Multiply = "multiply",
   Divide = "divide",
   Modulo = "modulo",
-  And = "and",
-  Or = "or"
+  Ternary = "ternary",
+  ToString = "to-string",
+  ToNumber = "to-number",
+  ToBoolean = "to-boolean",
+  Call = "call"
 }
-type TDynamicVariableTarget = {
-  chainMode?: EVarType;
-  chainVariables?: Array<{
-    operation: EDynamicVariableChain;
-    value: TMaybeDynamicVariable<true>;
-  }>;
-  mode?: EVarType;
-  operation: EDynamicVariableOperation;
+/**
+ * One operation applied to the previous value, optionally followed by a property access on its result.
+ */
+type TDynamicVariableStep = {
+  access?: Array<string>;
+  operation: EDynamicOperation;
   variables: Array<TMaybeDynamicVariable<true>>;
 };
 /**
@@ -871,7 +924,7 @@ type TBaseDynamicVariable = {
   type: EDynamicVariableType;
   _dynamic: true;
   access: Array<string>;
-  target?: TDynamicVariableTarget;
+  steps?: Array<TDynamicVariableStep>;
   token: string;
   value: unknown;
 };
@@ -903,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
@@ -955,6 +1030,7 @@ type TBasePlugin<TConfig extends TSchema = TSchema, TInternals = unknown> = {
       name: string;
       version?: string;
     }>;
+    env?: Record<string, string>;
     frontImports?: Array<{
       name: string;
       version?: string;
@@ -975,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 & {
@@ -1020,6 +1097,7 @@ type TEnv<TConfig extends TSchema = TSchema, TInternals = unknown> = {
   config: Static<TConfig>;
   getFile: (id: string) => TFile | undefined;
   internals: TInternals;
+  log: (message: string, severity?: "info" | "warning" | "error") => void;
   mode: "build" | "editor";
 };
 type TOption<TParams = unknown, TResult = unknown> = TResult | ((env: TParams) => Promise<TResult> | TResult);
@@ -1030,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 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-JzydDdZn.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
@@ -20,6 +20,8 @@ var LSettingsStoryWrapper_default = /*#__PURE__*/ export_helper_default(_sfc_mai
 let EPluginHooks = /* @__PURE__ */ function(EPluginHooks) {
 	EPluginHooks["BackendMiddleware"] = "backend/middleware";
 	EPluginHooks["BackendInputNode"] = "backend/input-node";
+	EPluginHooks["DatabaseScope"] = "database/scope";
+	EPluginHooks["DatabaseChange"] = "database/change";
 	return EPluginHooks;
 }({});
 //#endregion
@@ -183,9 +185,7 @@ let EPlanKey = /* @__PURE__ */ function(EPlanKey) {
 const flags = {
 	free: {
 		compilation: {
-			desktop: false,
 			export: true,
-			mobile: false,
 			source: false,
 			web: true
 		},
@@ -193,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
 		},
@@ -207,6 +209,10 @@ const flags = {
 			desktop: true,
 			web: true
 		},
+		desktop: { compilation: {
+			desktop: true,
+			mobile: true
+		} },
 		watermark: false
 	}
 };
@@ -215,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({
@@ -383,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(),
@@ -407,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 = {
@@ -809,6 +799,7 @@ const tick = {
 	url: "/turnstile/tick"
 };
 var user_exports = /* @__PURE__ */ __exportAll({
+	acceptTerms: () => acceptTerms,
 	confirmAccountDeletion: () => confirmAccountDeletion,
 	disconnect: () => disconnect,
 	get: () => get,
@@ -831,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),
@@ -908,6 +905,46 @@ function getContent(response) {
 	if (response.headers.get("Content-Type")?.startsWith("application/json")) return response.json();
 	return response.text();
 }
+function isSchemaType(schema, ...types) {
+	if (schema?.type === EVarType.union) return schema.elements.length > 0 && schema.elements.every((element) => isSchemaType(element, ...types));
+	return Boolean(schema && types.includes(schema.type));
+}
+function strip(schema) {
+	const result = { ...schema };
+	delete result.default;
+	delete result.name;
+	delete result.optional;
+	return result;
+}
+function named(schema, name) {
+	return {
+		...strip(schema),
+		name
+	};
+}
+function binary(operator, precedence, types, evaluate, output) {
+	return {
+		accepts: (input) => isSchemaType(input, ...types),
+		argPrecedence: precedence + 1,
+		args: (input) => [named(input, "Value")],
+		evaluate,
+		inputPrecedence: precedence,
+		output: output ?? ((input) => strip(input)),
+		precedence,
+		print: (input, [arg]) => `${input} ${operator} ${arg}`
+	};
+}
+function comparison(operator, precedence, types, evaluate) {
+	return binary(operator, precedence, types, evaluate, () => LogicType.boolean());
+}
+const primitives = [
+	EVarType.boolean,
+	EVarType.number,
+	EVarType.string,
+	EVarType.unknown
+];
+const ordered = [EVarType.number, EVarType.string];
+comparison("===", 8, primitives, (input, [arg]) => input === arg), comparison("!==", 8, primitives, (input, [arg]) => input !== arg), comparison(">", 9, ordered, (input, [arg]) => input > arg), comparison(">=", 9, ordered, (input, [arg]) => input >= arg), comparison("<", 9, ordered, (input, [arg]) => input < arg), comparison("<=", 9, ordered, (input, [arg]) => input <= arg), binary("&&", 4, [EVarType.boolean], (input, [arg]) => Boolean(input && arg)), binary("||", 3, primitives, (input, [arg]) => input || arg), binary("+", 11, [EVarType.number, EVarType.string], (input, [arg]) => input + arg), binary("-", 11, [EVarType.number], (input, [arg]) => input - arg), binary("*", 12, [EVarType.number], (input, [arg]) => input * arg), binary("/", 12, [EVarType.number], (input, [arg]) => input / arg), binary("%", 12, [EVarType.number], (input, [arg]) => input % arg), EVarType.boolean, EVarType.number, EVarType.unknown, LogicType.string(), EVarType.boolean, EVarType.string, EVarType.unknown, LogicType.number(), EVarType.number, EVarType.string, EVarType.unknown, LogicType.boolean();
 //#endregion
 //#region src/index.ts
 function makePlugin(plugin) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luna-park/plugin",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "private": false,
   "description": "Plugin helper for Luna Park.",
   "homepage": "https://luna-park.app",