@video-editor/shared 0.0.1-beta.1

package/README.md

@@ -0,0 +1,3 @@
+# @video-editor/shared
+
+video editor libs common type

package/dist/index.d.ts

@@ -0,0 +1,263 @@
+declare interface AudioSegment<T extends ITrackType> extends ISegment<T> {
+    segmentType: T;
+    url: string;
+    fromTime?: number;
+    volume?: number;
+    fadeInDuration?: number;
+    fadeOutDuration?: number;
+    playRate?: number;
+}
+
+/**
+ * Protocol version constant
+ */
+export declare const CURRENT_PROTOCOL_VERSION: "1.0.0";
+
+declare interface EffectSegment<T extends ITrackType> extends ISegment<T> {
+    segmentType: T;
+    effectId: string;
+    name: string;
+}
+
+declare interface FilterSegment<T extends ITrackType> extends ISegment<T> {
+    segmentType: T;
+    filterId: string;
+    name: string;
+    intensity?: number;
+}
+
+/**
+ * Get segment duration in milliseconds
+ */
+export declare function getSegmentDuration(segment: SegmentUnion): number;
+
+export declare interface I3DFramesSegment extends IFramesSegment {
+    type: '3D';
+}
+
+export declare interface IAnimation {
+    id: string;
+    name: string;
+    duration: number;
+    type: 'in' | 'out' | 'combo';
+    url?: string;
+}
+
+export declare type IAudioSegment = AudioSegment<'audio'>;
+
+export declare interface IBackground {
+    color?: string;
+    opacity?: number;
+}
+
+export declare interface IDropShadow {
+    color?: string;
+    opacity?: number;
+    blur?: number;
+    distance?: number;
+    angle?: number;
+}
+
+export declare type IEffectSegment = EffectSegment<'effect'>;
+
+export declare type IFillMode = 'none' | 'contain' | 'cover' | 'stretch';
+
+export declare type IFilterSegment = FilterSegment<'filter'>;
+
+declare interface IFramesSegment extends ISegment<'frames'> {
+    type: 'image' | 'video' | '3D';
+    url: string;
+    transform?: ITransform;
+    opacity?: number;
+    fillMode?: IFillMode;
+    animation?: IAnimation;
+    transitionIn?: ITransition;
+    transitionOut?: ITransition;
+    palette?: IPalette;
+    background?: `rgba(${number},${number},${number},${number})`;
+}
+
+export declare type IFramesSegmentUnion = IVideoFramesSegment | IImageFramesSegment | I3DFramesSegment;
+
+export declare interface IImageFramesSegment extends IFramesSegment {
+    type: 'image';
+    format: 'img' | 'gif';
+}
+
+export declare type IImageSegment = ImageSegment<'image'>;
+
+declare interface ImageSegment<T extends ITrackType> extends ISegment<T> {
+    segmentType: T;
+    format: 'img' | 'gif';
+    url: string;
+    fillMode?: IFillMode;
+    animation?: IAnimation;
+    transform?: ITransform;
+    palette?: IPalette;
+}
+
+export declare interface IPalette {
+    temperature: number;
+    hue: number;
+    saturation: number;
+    brightness: number;
+    contrast: number;
+    shine: number;
+    highlight: number;
+    shadow: number;
+    sharpness: number;
+    vignette: number;
+    fade: number;
+    grain: number;
+}
+
+/**
+ * Type guard: check if segment is audio segment
+ */
+export declare function isAudioSegment(segment: SegmentUnion): segment is IAudioSegment;
+
+/**
+ * Type guard: check if segment is effect segment
+ */
+export declare function isEffectSegment(segment: SegmentUnion): segment is IEffectSegment;
+
+export declare interface ISegment<T extends ITrackType> {
+    id: string;
+    startTime: number;
+    endTime: number;
+    segmentType: T;
+    url?: string;
+}
+
+/**
+ * Type guard: check if segment is filter segment
+ */
+export declare function isFilterSegment(segment: SegmentUnion): segment is IFilterSegment;
+
+/**
+ * Type guard: check if segment is frames segment
+ */
+export declare function isFramesSegment(segment: SegmentUnion): segment is IFramesSegmentUnion;
+
+/**
+ * Type guard: check if segment is image segment
+ */
+export declare function isImageSegment(segment: SegmentUnion): segment is IImageSegment;
+
+/**
+ * Type guard: check if segment is text segment
+ */
+export declare function isTextSegment(segment: SegmentUnion): segment is ITextSegment;
+
+/**
+ * Check if a time point is within a segment's time range
+ */
+export declare function isTimeInSegment(time: number, segment: SegmentUnion): boolean;
+
+export declare interface IStroke {
+    color?: string;
+    width?: number;
+    opacity?: number;
+}
+
+/**
+ * Check if a string is a valid track type
+ */
+export declare function isValidTrackType(type: string): type is ITrackType;
+
+/**
+ * Type guard: check if segment is video frames segment
+ */
+export declare function isVideoFramesSegment(segment: SegmentUnion): segment is IVideoFramesSegment;
+
+export declare interface ITextBasic {
+    content: string;
+    align?: 'left' | 'center' | 'right' | 'justify';
+    dropShadow?: IDropShadow;
+    fontFamily?: string | string[];
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold' | 'bolder' | 'lighter' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+    fontStyle?: 'normal' | 'italic' | 'oblique';
+    underline?: boolean;
+    fill?: string;
+    letterSpacing?: number;
+    leading?: number;
+    stroke?: IStroke;
+    background?: IBackground;
+}
+
+export declare type ITextSegment = TextSegment<'text'>;
+
+export declare type ITrack<T extends ITrackType> = {
+    trackId: string;
+    trackType: T;
+    children: TrackTypeMapSegment[T][];
+} & (T extends 'frames' ? {
+    isMain?: boolean;
+} : object);
+
+export declare type ITrackType = keyof TrackTypeMapSegment;
+
+export declare interface ITransform {
+    position: [number, number, number];
+    rotation: [number, number, number];
+    scale: [number, number, number];
+}
+
+export declare interface ITransition {
+    id: string;
+    name: string;
+    duration: number;
+}
+
+export declare interface IVideoFramesSegment extends IFramesSegment {
+    type: 'video';
+    fromTime?: number;
+    volume?: number;
+    playRate?: number;
+}
+
+/**
+ * NOTE: that without special explanation:
+ * the time related value is in ms
+ * the numerical value is normalized in range [0, 1] unless otherwise specified
+ */
+export declare interface IVideoProtocol {
+    version: `${number}.${number}.${number}`;
+    width: number;
+    height: number;
+    fps: number;
+    tracks: TrackUnion[];
+}
+
+export declare type SegmentUnion = TrackTypeMapSegment[ITrackType];
+
+declare interface TextSegment<T extends ITrackType> extends ISegment<T> {
+    segmentType: T;
+    texts: ITextBasic[];
+    transform?: ITransform;
+    opacity?: number;
+    animation?: IAnimation;
+}
+
+/**
+ * Track type constants
+ */
+export declare const TRACK_TYPES: readonly ITrackType[];
+
+export declare interface TrackTypeMapSegment {
+    frames: IFramesSegmentUnion;
+    text: TextSegment<'text'>;
+    image: ImageSegment<'image'>;
+    audio: AudioSegment<'audio'>;
+    effect: EffectSegment<'effect'>;
+    filter: FilterSegment<'filter'>;
+}
+
+export declare type TrackTypeMapTrack = {
+    [Key in ITrackType]: ITrack<Key>;
+};
+
+export declare type TrackUnion = TrackTypeMapTrack[ITrackType];
+
+export { }

package/dist/videoEditorShared.js

@@ -0,0 +1,46 @@
+const i = "1.0.0";
+function r(e) {
+  return e.segmentType === "frames";
+}
+function u(e) {
+  return e.segmentType === "frames" && "type" in e && e.type === "video";
+}
+function m(e) {
+  return e.segmentType === "text";
+}
+function s(e) {
+  return e.segmentType === "image";
+}
+function f(e) {
+  return e.segmentType === "audio";
+}
+function o(e) {
+  return e.segmentType === "effect";
+}
+function T(e) {
+  return e.segmentType === "filter";
+}
+function c(e) {
+  return e.endTime - e.startTime;
+}
+function g(e, t) {
+  return e >= t.startTime && e < t.endTime;
+}
+const n = ["frames", "text", "image", "audio", "effect", "filter"];
+function a(e) {
+  return n.includes(e);
+}
+export {
+  i as CURRENT_PROTOCOL_VERSION,
+  n as TRACK_TYPES,
+  c as getSegmentDuration,
+  f as isAudioSegment,
+  o as isEffectSegment,
+  T as isFilterSegment,
+  r as isFramesSegment,
+  s as isImageSegment,
+  m as isTextSegment,
+  g as isTimeInSegment,
+  a as isValidTrackType,
+  u as isVideoFramesSegment
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@video-editor/shared",
+  "type": "module",
+  "version": "0.0.1-beta.1",
+  "description": "video editor shared libs",
+  "author": "",
+  "license": "ISC",
+  "keywords": [],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build --config vite.config.ts"
+  }
+}