@video-editor/editor-core 0.0.1-beta.17

package/README.md

@@ -0,0 +1,3 @@
+# @video-editor/editor-core
+
+Headless editor core built on the reactive video protocol. It exposes state, commands, selectors, and a plugin registry without any UI dependencies.

package/dist/index.d.ts

@@ -0,0 +1,251 @@
+import { ComputedRef } from '@vue/reactivity';
+import { createVideoProtocolManager } from '@video-editor/protocol';
+import { DeepReadonly } from '@vue/reactivity';
+import { ITrackType } from '@video-editor/shared';
+import { IVideoProtocol } from '@video-editor/shared';
+import { SegmentUnion } from '@video-editor/shared';
+import { TrackUnion } from '@video-editor/shared';
+
+/** Result payload returned by addSegment. */
+export declare type AddSegmentResult = ReturnType<ProtocolManager['addSegment']>;
+
+export declare function createEditorCore(options: EditorCoreOptions): EditorCore;
+
+export declare function createPluginManager(ctx: EditorCoreContext): EditorCorePluginManager;
+
+export declare function createSegmentRegistry(): SegmentRegistry;
+
+/**
+ * The headless editor-core instance.
+ */
+export declare interface EditorCore {
+    /** Read-only state tree. */
+    state: EditorCoreState;
+    /** Mutation commands. */
+    commands: EditorCoreCommands;
+    /** Read-only selectors. */
+    selectors: EditorCoreSelectors;
+    /** Plugin manager instance. */
+    plugins: EditorCorePluginManager;
+    /** Segment plugin registry. */
+    registry: {
+        segments: SegmentRegistry;
+    };
+    /** Shared services passed at initialization. */
+    services: EditorCoreServices;
+    /** Dispose resources. */
+    destroy: () => Promise<void>;
+}
+
+/**
+ * Commands are the only supported way to mutate protocol state.
+ */
+export declare interface EditorCoreCommands {
+    /** Set the playhead time in ms. */
+    setCurrentTime: (time: number) => void;
+    /** Update the selected segment id. */
+    setSelectedSegment: ProtocolManager['setSelectedSegment'];
+    /** Insert a segment into the timeline. */
+    addSegment: ProtocolManager['addSegment'];
+    /** Remove a segment by id. */
+    removeSegment: ProtocolManager['removeSegment'];
+    /** Mutate a segment (by id or current selection). */
+    updateSegment: ProtocolManager['updateSegment'];
+    /** Move a segment between tracks or positions. */
+    moveSegment: ProtocolManager['moveSegment'];
+    /** Resize a segment's time range. */
+    resizeSegment: ProtocolManager['resizeSegment'];
+    /** Add a transition at the current time or a specified time. */
+    addTransition: ProtocolManager['addTransition'];
+    /** Remove a transition by segment id. */
+    removeTransition: ProtocolManager['removeTransition'];
+    /** Update a transition by segment id. */
+    updateTransition: ProtocolManager['updateTransition'];
+    /** Replace a track id (useful for migrations). */
+    replaceTrackId: ProtocolManager['replaceTrackId'];
+    /** Undo the last mutation. */
+    undo: ProtocolManager['undo'];
+    /** Redo the last undone mutation. */
+    redo: ProtocolManager['redo'];
+    /** Export the current protocol as a plain object snapshot. */
+    exportProtocol: ProtocolManager['exportProtocol'];
+}
+
+/**
+ * The context passed to plugin creators.
+ */
+export declare interface EditorCoreContext {
+    state: EditorCoreState;
+    commands: EditorCoreCommands;
+    selectors: EditorCoreSelectors;
+    registry: {
+        segments: SegmentRegistry;
+    };
+    services: EditorCoreServices;
+}
+
+/**
+ * Editor-core initialization options.
+ */
+export declare interface EditorCoreOptions {
+    /** Initial protocol snapshot. */
+    protocol: IVideoProtocol;
+    /** Optional id generators for segments/tracks. */
+    idFactory?: {
+        segment?: () => string;
+        track?: () => string;
+    };
+    /** Optional shared services (resource manager, renderer, etc). */
+    services?: EditorCoreServices;
+}
+
+/**
+ * Base plugin interface for editor-core.
+ */
+export declare interface EditorCorePlugin {
+    /** Plugin name, must be unique within the editor instance. */
+    name: string;
+    /** Initialize side effects or register UI/handlers. */
+    init?: () => Promise<void> | void;
+    /** Cleanup side effects. */
+    destroy?: () => Promise<void> | void;
+    /** Optional plugin metadata. */
+    meta?: {
+        dependencies?: string[];
+    };
+}
+
+/** Create a plugin from the editor context. */
+export declare type EditorCorePluginCreator = (ctx: EditorCoreContext) => EditorCorePlugin;
+
+/**
+ * Plugin manager used by editor-core.
+ */
+export declare interface EditorCorePluginManager {
+    /** Register a plugin creator. */
+    register: (pluginCreator: EditorCorePluginCreator, options?: {
+        autoInit?: boolean;
+        override?: boolean;
+    }) => Promise<void>;
+    /** Initialize all registered plugins. */
+    init: () => Promise<void>;
+    /** Fetch a plugin by name. */
+    get: (pluginName: string) => EditorCorePlugin | undefined;
+    /** Check if a plugin exists. */
+    has: (pluginName: string) => boolean;
+    /** Remove a plugin by name (calls destroy). */
+    remove: (pluginName: string) => Promise<boolean>;
+    /** Destroy and clear all plugins. */
+    destroy: () => Promise<void>;
+}
+
+/**
+ * Read-only helpers for querying protocol data.
+ */
+export declare interface EditorCoreSelectors {
+    /** Find a segment by id (and optionally type). */
+    getSegment: ProtocolManager['getSegment'];
+    /** Find a track by id (read-only reference). */
+    getTrackById: (trackId: string) => DeepReadonly<TrackUnion> | undefined;
+    /** Find the track that owns a segment id. */
+    getTrackBySegmentId: (segmentId: string) => DeepReadonly<TrackUnion> | undefined;
+    /** List tracks, optionally filtered by type. */
+    getTracks: (trackType?: ITrackType) => DeepReadonly<TrackUnion>[];
+}
+
+/**
+ * Arbitrary shared services injected into editor-core (resource, renderer, etc).
+ */
+export declare interface EditorCoreServices {
+    [key: string]: unknown;
+}
+
+/**
+ * Read-only editor state derived from the reactive protocol.
+ * All mutations should go through commands.
+ */
+export declare interface EditorCoreState {
+    /** Reactive protocol snapshot. */
+    protocol: ProtocolManager['protocol'];
+    /** Project-level properties (width/height/fps/version). */
+    videoBasicInfo: ProtocolManager['videoBasicInfo'];
+    /** Current playhead time in ms. */
+    currentTime: ProtocolManager['curTime'];
+    /** Currently selected segment (read-only). */
+    selectedSegment: ProtocolManager['selectedSegment'];
+    /** Selected segment id, derived from the current selection. */
+    selectedSegmentId: ComputedRef<string | undefined>;
+    /** Track list grouped by segment type. */
+    trackMap: ProtocolManager['trackMap'];
+    /** Segment lookup table keyed by segment id. */
+    segmentMap: ProtocolManager['segmentMap'];
+    /** Total duration computed from protocol tracks. */
+    duration: ComputedRef<number>;
+    /** Undo stack size. */
+    undoCount: ProtocolManager['undoCount'];
+    /** Redo stack size. */
+    redoCount: ProtocolManager['redoCount'];
+}
+
+/** Options for moving a segment between tracks or within a track. */
+export declare type MoveSegmentOptions = Parameters<ProtocolManager['moveSegment']>[0];
+
+/** Internal protocol manager type used to align editor-core signatures with protocol behavior. */
+declare type ProtocolManager = ReturnType<typeof createVideoProtocolManager>;
+
+/** Options for resizing a segment on a track. */
+export declare type ResizeSegmentOptions = Parameters<ProtocolManager['resizeSegment']>[0];
+
+/** Input payload for adding a segment (id is optional). */
+export declare type SegmentInput = Parameters<ProtocolManager['addSegment']>[0];
+
+/** Result payload returned by segment mutation commands. */
+export declare type SegmentMutationResult = ReturnType<ProtocolManager['removeSegment']>;
+
+/**
+ * Segment plugin bundle: ops + renderer adapter + optional UI bindings.
+ */
+export declare interface SegmentPlugin<TSegment extends SegmentUnion = SegmentUnion, RenderNode = unknown, UI = SegmentPluginUI> {
+    /** The segment type this plugin handles. */
+    type: TSegment['segmentType'];
+    /** Optional operations for this segment type. */
+    ops?: SegmentPluginOps<TSegment>;
+    /** Convert a segment into a renderer-specific node. */
+    renderer?: {
+        toRenderNode: (segment: TSegment, ctx: EditorCoreContext) => RenderNode | null;
+    };
+    /** Optional UI bindings (panel, track, resource). */
+    ui?: UI;
+}
+
+/**
+ * Optional behavior hooks for a segment type.
+ */
+export declare interface SegmentPluginOps<TSegment extends SegmentUnion = SegmentUnion> {
+    create?: (ctx: EditorCoreContext, partial?: Partial<TSegment>) => TSegment;
+    update?: (ctx: EditorCoreContext, id: string, patch: Partial<TSegment>) => void;
+    remove?: (ctx: EditorCoreContext, id: string) => void;
+    split?: (ctx: EditorCoreContext, id: string, time: number) => void;
+}
+
+/**
+ * Optional UI bindings for a segment plugin (editor-ui can consume these).
+ */
+export declare interface SegmentPluginUI {
+    panel?: unknown;
+    track?: unknown;
+    resource?: unknown;
+}
+
+/**
+ * Registry for segment-type plugins (type -> plugin lookup).
+ */
+export declare interface SegmentRegistry {
+    register: (plugin: SegmentPlugin, options?: {
+        override?: boolean;
+    }) => void;
+    get: (type: ITrackType) => SegmentPlugin | undefined;
+    list: () => SegmentPlugin[];
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,116 @@
+import { computed as p } from "@vue/reactivity";
+import { createVideoProtocolManager as v } from "@video-editor/protocol";
+function y(s) {
+  const e = [], r = /* @__PURE__ */ new Map();
+  let a = !1;
+  return {
+    register: async (t, n) => {
+      const i = t(s), { name: c } = i;
+      if (r.has(c)) {
+        if (!n?.override)
+          throw new Error(`Plugin ${c} has been registered`);
+        await r.get(c)?.destroy?.();
+        const u = e.findIndex((S) => S.name === c);
+        u >= 0 && e.splice(u, 1), r.delete(c);
+      }
+      e.push(i), r.set(c, i), (n?.autoInit || a) && await i.init?.();
+    },
+    init: async () => {
+      for (const t of e)
+        await t.init?.();
+      a = !0;
+    },
+    get: (t) => r.get(t),
+    has: (t) => r.has(t),
+    remove: async (t) => {
+      const n = e.findIndex((c) => c.name === t);
+      return n === -1 ? !1 : (await e[n].destroy?.(), e.splice(n, 1), r.delete(t));
+    },
+    destroy: async () => {
+      for (const t of e)
+        await t.destroy?.();
+      e.length = 0, r.clear(), a = !1;
+    }
+  };
+}
+function T() {
+  const s = /* @__PURE__ */ new Map();
+  return {
+    register: (o, d) => {
+      if (s.has(o.type) && !d?.override)
+        throw new Error(`Segment plugin ${o.type} has been registered`);
+      s.set(o.type, o);
+    },
+    get: (o) => s.get(o),
+    list: () => [...s.values()]
+  };
+}
+function k(s) {
+  let e = 0;
+  for (const r of s)
+    for (const a of r.children)
+      a.endTime > e && (e = a.endTime);
+  return e;
+}
+function I(s) {
+  const e = v(s.protocol, {
+    idFactory: s.idFactory
+  }), r = p(() => e.selectedSegment.value?.id), a = p(() => k(e.protocol.value.tracks)), o = {
+    protocol: e.protocol,
+    videoBasicInfo: e.videoBasicInfo,
+    currentTime: e.curTime,
+    selectedSegment: e.selectedSegment,
+    selectedSegmentId: r,
+    trackMap: e.trackMap,
+    segmentMap: e.segmentMap,
+    duration: a,
+    undoCount: e.undoCount,
+    redoCount: e.redoCount
+  }, d = {
+    setCurrentTime: (n) => {
+      e.curTime.value = n;
+    },
+    setSelectedSegment: e.setSelectedSegment,
+    addSegment: e.addSegment,
+    removeSegment: e.removeSegment,
+    updateSegment: e.updateSegment,
+    moveSegment: e.moveSegment,
+    resizeSegment: e.resizeSegment,
+    addTransition: e.addTransition,
+    removeTransition: e.removeTransition,
+    updateTransition: e.updateTransition,
+    replaceTrackId: e.replaceTrackId,
+    undo: e.undo,
+    redo: e.redo,
+    exportProtocol: e.exportProtocol
+  }, g = {
+    getSegment: e.getSegment,
+    getTrackById: (n) => o.protocol.value.tracks.find((i) => i.trackId === n),
+    getTrackBySegmentId: (n) => o.protocol.value.tracks.find((i) => i.children.some((c) => c.id === n)),
+    getTracks: (n) => n ? o.protocol.value.tracks.filter((i) => i.trackType === n) : o.protocol.value.tracks
+  }, l = {
+    segments: T()
+  }, m = s.services ?? {}, t = y({
+    state: o,
+    commands: d,
+    selectors: g,
+    registry: l,
+    services: m
+  });
+  return {
+    state: o,
+    commands: d,
+    selectors: g,
+    plugins: t,
+    registry: l,
+    services: m,
+    destroy: async () => {
+      await t.destroy();
+    }
+  };
+}
+export {
+  I as createEditorCore,
+  y as createPluginManager,
+  T as createSegmentRegistry
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@video-editor/editor-core",
+  "type": "module",
+  "version": "0.0.1-beta.17",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@vue/reactivity": "^3.5.26"
+  },
+  "dependencies": {
+    "@video-editor/protocol": "0.0.1-beta.17",
+    "@video-editor/shared": "0.0.1-beta.17"
+  },
+  "devDependencies": {
+    "@vue/reactivity": "^3.5.26"
+  },
+  "scripts": {
+    "build:types": "vue-tsc --declaration --emitDeclarationOnly",
+    "build": "vite build",
+    "preview": "vite preview"
+  }
+}