@pipelab/shared 1.0.0-beta.1 → 1.0.0-beta.11

package/src/model.ts

@@ -32,6 +32,14 @@ export type Position = {
 export const OriginValidator = object({
   pluginId: string(),
   nodeId: string(),
+  version: optional(
+    pipe(
+      string(),
+      description(
+        'Pinned version of the plugin for this block. Falls back to "latest" when absent.',
+      ),
+    ),
+  ),
 });
 
 export type Origin = InferOutput<typeof OriginValidator>;
@@ -49,7 +57,7 @@ export type EditorParam = InferOutput<typeof EditorParamValidatorV3>;
 const BlockActionValidatorV3 = object({
   type: literal("action"),
   uid: string(),
-  name: pipe(optional(string()), description("A custom name provided by the user")),
+  name: optional(pipe(string(), description("A custom name provided by the user"))),
   disabled: optional(boolean()),
   params: record(
     string(),
@@ -61,39 +69,6 @@ const BlockActionValidatorV3 = object({
   origin: OriginValidator,
 });
 
-export type BlockCondition = {
-  type: "condition";
-  uid: string;
-  origin: Origin;
-  params: Record<string, any>;
-  branchTrue: Array<Block>;
-  branchFalse: Array<Block>;
-};
-
-const BlockConditionValidator: GenericSchema<BlockCondition> = object({
-  type: literal("condition"),
-  uid: string(),
-  origin: OriginValidator,
-  params: record(string(), any()),
-  branchTrue: lazy(() => array(BlockValidator)),
-  branchFalse: lazy(() => array(BlockValidator)),
-});
-
-export type BlockLoop = {
-  type: "loop";
-  uid: string;
-  origin: Origin;
-  params: Record<string, any>;
-  children: Array<Block>;
-};
-const BlockLoopValidator: GenericSchema<BlockLoop> = object({
-  type: literal("loop"),
-  uid: string(),
-  origin: OriginValidator,
-  params: record(string(), any()),
-  children: lazy(() => array(BlockValidator)),
-});
-
 const BlockEventValidator = object({
   type: literal("event"),
   uid: string(),
@@ -180,20 +155,22 @@ export const SavedFileValidatorV3 = object({
   variables: array(VariableValidatorV1),
 });
 
-export const SavedFileDefaultValidator = object({
+export const SavedFileDefaultValidatorV4 = object({
   version: literal("4.0.0"),
   type: literal("default"),
   name: string(),
   description: string(),
+  plugins: optional(record(string(), string())),
   canvas: CanvasValidatorV3,
   variables: array(VariableValidatorV1),
 });
 
-export const SavedFileSimpleValidator = object({
+export const SavedFileSimpleValidatorV4 = object({
   version: literal("4.0.0"),
   type: literal("simple"),
   name: string(),
   description: string(),
+  plugins: optional(record(string(), string())),
   source: object({
     type: union([literal("c3-html"), literal("c3-nwjs"), literal("godot"), literal("html")]),
     path: string(),
@@ -208,19 +185,53 @@ export const SavedFileSimpleValidator = object({
   }),
 });
 
-export type SavedFileDefault = InferOutput<typeof SavedFileDefaultValidator>;
-export type SavedFileSimple = InferOutput<typeof SavedFileSimpleValidator>;
-export const SavedFileValidatorV4 = union([SavedFileDefaultValidator, SavedFileSimpleValidator]);
+export const SavedFileDefaultValidatorV5 = object({
+  version: literal("5.0.0"),
+  name: string(),
+  description: string(),
+  canvas: CanvasValidatorV3,
+  variables: array(VariableValidatorV1),
+});
+
+export const SavedFileSimpleValidatorV5 = object({
+  version: literal("5.0.0"),
+  type: literal("simple"),
+  name: string(),
+  description: string(),
+  plugins: record(string(), string()),
+  source: object({
+    type: union([literal("c3-html"), literal("c3-nwjs"), literal("godot"), literal("html")]),
+    path: string(),
+  }),
+  packaging: object({
+    enabled: boolean(),
+  }),
+  publishing: object({
+    steam: object({ enabled: boolean(), appId: optional(string()) }),
+    itch: object({ enabled: boolean(), project: optional(string()) }),
+    poki: object({ enabled: boolean(), gameId: optional(string()) }),
+  }),
+});
+
+export type SavedFileDefault = InferOutput<typeof SavedFileDefaultValidatorV5>;
+export type SavedFileSimple = InferOutput<typeof SavedFileSimpleValidatorV5>;
+
+export const SavedFileValidatorV4 = union([
+  SavedFileDefaultValidatorV4,
+  SavedFileSimpleValidatorV4,
+]);
+export const SavedFileValidatorV5 = SavedFileDefaultValidatorV5;
 
 export type SavedFileV1 = InferOutput<typeof SavedFileValidatorV1>;
 export type SavedFileV2 = InferOutput<typeof SavedFileValidatorV2>;
 export type SavedFileV3 = InferOutput<typeof SavedFileValidatorV3>;
 export type SavedFileV4 = InferOutput<typeof SavedFileValidatorV4>;
-export type SavedFile = SavedFileV4;
-export const SavedFileValidator = SavedFileValidatorV4;
+export type SavedFileV5 = InferOutput<typeof SavedFileValidatorV5>;
+export type SavedFile = SavedFileV5;
+export const SavedFileValidator = SavedFileValidatorV5;
 
 export type Preset = SavedFile;
-export type PresetResult = { data: SavedFile; hightlight?: boolean; disabled?: boolean };
+export type PresetResult = { data: Preset; hightlight?: boolean; disabled?: boolean };
 export type PresetFn = () => Promise<PresetResult>;
 
 export type Steps = Record<
@@ -230,4 +241,4 @@ export type Steps = Record<
   }
 >;
 
-export type EnhancedFile<T extends SavedFile = SavedFile> = WithId<SaveLocation> & { content: T };
+export type EnhancedFile<T = SavedFile> = WithId<SaveLocation> & { content: T };

package/src/plugins/definitions.ts

@@ -154,18 +154,36 @@ export type IconType =
       icon: string;
     };
 export interface PluginDefinition {
-  id: string;
-  name: string;
-  icon: IconType;
-  description: string;
+  packageName?: string;
+  version?: string;
 }
 
 export type RendererNodeDefinition = {
   node: PipelabNode;
 };
 
+export interface IntegrationField {
+  key: string;
+  label: string;
+  type: "text" | "password" | "file" | "directory";
+  placeholder?: string;
+}
+
+export interface IntegrationDefinition {
+  name: string;
+  fields: IntegrationField[];
+}
+
 export interface RendererPluginDefinition extends PluginDefinition {
+  id: string;
+  name: string;
+  icon: IconType;
+  description: string;
+  isOfficial: boolean;
+  packageName: string;
+  version: string;
   nodes: Array<RendererNodeDefinition>;
+  integrations?: Array<IntegrationDefinition>;
 }
 
 export interface MainPluginDefinition extends PluginDefinition {
@@ -177,6 +195,7 @@ export interface MainPluginDefinition extends PluginDefinition {
     description: string;
     validator: (options: any) => any;
   }>;
+  integrations?: Array<IntegrationDefinition>;
 }
 
 export const createNodeDefinition = (def: MainPluginDefinition) => {
@@ -203,10 +222,7 @@ export type SetOutputActionFn<T extends Action> = (
   key: keyof T["outputs"],
   value: T["outputs"][typeof key]["value"],
 ) => void;
-export type SetOutputLoopFn<T extends Loop> = (
-  key: keyof T["outputs"],
-  value: T["outputs"][typeof key]["value"],
-) => void;
+
 export type SetOutputExpressionFn<T extends Expression> = (
   key: keyof T["outputs"],
   value: T["outputs"][typeof key]["value"],
@@ -244,12 +260,6 @@ export type ExtractInputsFromAction<ACTION extends Action> = {
   [index in keyof ACTION["params"]]: ACTION["params"][index]["value"];
 };
 
-export type ExtractInputsFromCondition<CONDITION extends Condition> = {
-  [index in keyof CONDITION["params"]]: CONDITION["params"][index]["value"];
-};
-export type ExtractInputsFromLoop<LOOP extends Loop> = {
-  [index in keyof LOOP["params"]]: LOOP["params"][index]["value"];
-};
 export type ExtractInputsFromEvent<EVENT extends Event> = {
   [index in keyof EVENT["params"]]: EVENT["params"][index]["value"];
 };
@@ -257,32 +267,6 @@ export type ExtractInputsFromExpression<EXPRESSION extends Expression> = {
   [index in keyof EXPRESSION["params"]]: EXPRESSION["params"][index]["value"];
 };
 
-export interface Condition extends BaseNode {
-  id: string;
-  type: "condition";
-  version?: number;
-  displayString: string;
-  icon: string;
-  name: string;
-  description: string;
-  params: InputsDefinition;
-  meta?: Meta;
-  platforms?: NodeJS.Platform[];
-}
-
-export interface Loop extends BaseNode {
-  id: string;
-  type: "loop";
-  version?: number;
-  displayString: string;
-  icon: string;
-  name: string;
-  description: string;
-  params: InputsDefinition;
-  meta?: Meta;
-  outputs: OutputsDefinition;
-}
-
 export interface Expression extends BaseNode {
   id: string;
   type: "expression";
@@ -309,7 +293,7 @@ export interface Event extends BaseNode {
   platforms?: NodeJS.Platform[];
 }
 
-export type PipelabNode = Event | Condition | Expression | Action | Loop;
+export type PipelabNode = Event | Expression | Action;
 
 export const createDefinition = <T extends MainPluginDefinition>(definition: T) => {
   return definition satisfies T;
@@ -450,20 +434,6 @@ export const createExpression = <T extends Omit<Expression, "type">>(expression:
   } satisfies Expression;
 };
 
-export const createCondition = <T extends Omit<Condition, "type">>(condition: T) => {
-  return {
-    ...condition,
-    type: "condition",
-  } satisfies Condition;
-};
-
-export const createLoop = <T extends Omit<Loop, "type">>(loop: T) => {
-  return {
-    ...loop,
-    type: "loop",
-  } satisfies Loop;
-};
-
 export const createEvent = <T extends Omit<Event, "type">>(event: T) => {
   return {
     ...event,

package/src/plugins.ts

@@ -9,7 +9,16 @@ export const usePlugins = () => {
   const load = () => {};
 
   const registerPlugins = (newPlugins: Plugin[]) => {
-    plugins.value.push(...newPlugins);
+    const current = [...plugins.value];
+    for (const np of newPlugins) {
+      const idx = current.findIndex((p) => p.id === np.id);
+      if (idx !== -1) {
+        current[idx] = np;
+      } else {
+        current.push(np);
+      }
+    }
+    plugins.value = current;
   };
 
   return {

package/src/utils.ts

@@ -1,3 +1,29 @@
 export const foo = "bar";
 
 export type WithId<T> = T extends string | number ? never : T & { id: string };
+
+export const transformUrl = (url: string | undefined | null): string => {
+  if (url && typeof url === "string") {
+    const getHost = (): string => {
+      if (typeof window !== "undefined") {
+        const isDev = window.location.port === "5173";
+        if (isDev) {
+          return `http://${window.location.hostname}:33753`;
+        } else {
+          return `${window.location.protocol}//${window.location.host}`;
+        }
+      }
+      return "http://localhost:33753";
+    };
+
+    if (url.startsWith("file://")) {
+      const filePath = url.substring("file://".length);
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+    if (url.startsWith("media://")) {
+      const filePath = url.replace(/^media:\/\/+/, "/");
+      return `${getHost()}/media-file/${encodeURIComponent(filePath)}`;
+    }
+  }
+  return url || "";
+};

package/tsconfig.json

@@ -3,9 +3,7 @@
   "compilerOptions": {
     "emitDeclarationOnly": true,
     "outDir": "dist",
-    "baseUrl": ".",
-    "typeRoots": ["./src"],
-    "types": ["global.d.ts", "wasm.d.ts"]
+    "baseUrl": "."
   },
   "include": ["src/**/*", "tests/**/*", "*.ts", "src/**/*.json"],
   "exclude": ["node_modules", "dist"],