@shopify/react-native-skia 1.8.0 → 1.8.1

package/src/sksg/Recorder/commands/PathEffects.ts

@@ -0,0 +1,169 @@
+import { enumKey, processPath } from "../../../dom/nodes";
+import { NodeType } from "../../../dom/types";
+import type {
+  CornerPathEffectProps,
+  DashPathEffectProps,
+  DiscretePathEffectProps,
+  Line2DPathEffectProps,
+  Path1DPathEffectProps,
+  Path2DPathEffectProps,
+} from "../../../dom/types";
+import { Path1DEffectStyle } from "../../../skia/types";
+import { composeDeclarations } from "../../utils";
+import type { Command } from "../Core";
+import { CommandType } from "../Core";
+import type { DrawingContext } from "../DrawingContext";
+
+const declareDiscretePathEffect = (
+  ctx: DrawingContext,
+  props: DiscretePathEffectProps
+) => {
+  "worklet";
+  const { length, deviation, seed } = props;
+  const pe = ctx.Skia.PathEffect.MakeDiscrete(length, deviation, seed);
+  ctx.pathEffects.push(pe);
+};
+
+const declarePath2DPathEffect = (
+  ctx: DrawingContext,
+  props: Path2DPathEffectProps
+) => {
+  "worklet";
+  const { matrix } = props;
+  const path = processPath(ctx.Skia, props.path);
+  const pe = ctx.Skia.PathEffect.MakePath2D(matrix, path);
+  if (pe === null) {
+    throw new Error("Path2DPathEffect: invalid path");
+  }
+  ctx.pathEffects.push(pe);
+};
+
+const declareDashPathEffect = (
+  ctx: DrawingContext,
+  props: DashPathEffectProps
+) => {
+  "worklet";
+  const { intervals, phase } = props;
+  const pe = ctx.Skia.PathEffect.MakeDash(intervals, phase);
+  ctx.pathEffects.push(pe);
+};
+
+const declareCornerPathEffect = (
+  ctx: DrawingContext,
+  props: CornerPathEffectProps
+) => {
+  "worklet";
+  const { r } = props;
+  const pe = ctx.Skia.PathEffect.MakeCorner(r);
+  if (pe === null) {
+    throw new Error("CornerPathEffect: couldn't create path effect");
+  }
+  ctx.pathEffects.push(pe);
+};
+
+const declareSumPathEffect = (ctx: DrawingContext) => {
+  "worklet";
+  // Note: decorateChildren functionality needs to be handled differently
+  const pes = ctx.pathEffects.splice(0, ctx.pathEffects.length);
+  const pe = composeDeclarations(
+    pes,
+    ctx.Skia.PathEffect.MakeSum.bind(ctx.Skia.PathEffect)
+  );
+  ctx.pathEffects.push(pe);
+};
+
+const declareLine2DPathEffect = (
+  ctx: DrawingContext,
+  props: Line2DPathEffectProps
+) => {
+  "worklet";
+  const { width, matrix } = props;
+  const pe = ctx.Skia.PathEffect.MakeLine2D(width, matrix);
+  if (pe === null) {
+    throw new Error("Line2DPathEffect: could not create path effect");
+  }
+  ctx.pathEffects.push(pe);
+};
+
+const declarePath1DPathEffect = (
+  ctx: DrawingContext,
+  props: Path1DPathEffectProps
+) => {
+  "worklet";
+  const { advance, phase, style } = props;
+  const path = processPath(ctx.Skia, props.path);
+  const pe = ctx.Skia.PathEffect.MakePath1D(
+    path,
+    advance,
+    phase,
+    Path1DEffectStyle[enumKey(style)]
+  );
+  if (pe === null) {
+    throw new Error("Path1DPathEffect: could not create path effect");
+  }
+  ctx.pathEffects.push(pe);
+};
+
+export const isPushPathEffect = (
+  command: Command
+): command is Command<CommandType.PushPathEffect> => {
+  "worklet";
+  return command.type === CommandType.PushPathEffect;
+};
+
+type Props = {
+  [NodeType.DiscretePathEffect]: DiscretePathEffectProps;
+  [NodeType.DashPathEffect]: DashPathEffectProps;
+  [NodeType.Path1DPathEffect]: Path1DPathEffectProps;
+  [NodeType.Path2DPathEffect]: Path2DPathEffectProps;
+  [NodeType.CornerPathEffect]: CornerPathEffectProps;
+  [NodeType.SumPathEffect]: Record<string, never>;
+  [NodeType.Line2DPathEffect]: Line2DPathEffectProps;
+};
+
+interface PushPathEffect<T extends keyof Props>
+  extends Command<CommandType.PushPathEffect> {
+  pathEffectType: T;
+  props: Props[T];
+}
+
+const isPathEffect = <T extends keyof Props>(
+  command: Command<CommandType.PushPathEffect>,
+  type: T
+): command is PushPathEffect<T> => {
+  "worklet";
+  return command.pathEffectType === type;
+};
+
+export const composePathEffects = (ctx: DrawingContext) => {
+  "worklet";
+  if (ctx.pathEffects.length > 1) {
+    const outer = ctx.pathEffects.pop()!;
+    const inner = ctx.pathEffects.pop()!;
+    ctx.pathEffects.push(ctx.Skia.PathEffect.MakeCompose(outer, inner));
+  }
+};
+
+export const pushPathEffect = (
+  ctx: DrawingContext,
+  command: Command<CommandType.PushPathEffect>
+) => {
+  "worklet";
+  if (isPathEffect(command, NodeType.DiscretePathEffect)) {
+    declareDiscretePathEffect(ctx, command.props);
+  } else if (isPathEffect(command, NodeType.DashPathEffect)) {
+    declareDashPathEffect(ctx, command.props);
+  } else if (isPathEffect(command, NodeType.Path1DPathEffect)) {
+    declarePath1DPathEffect(ctx, command.props);
+  } else if (isPathEffect(command, NodeType.Path2DPathEffect)) {
+    declarePath2DPathEffect(ctx, command.props);
+  } else if (isPathEffect(command, NodeType.CornerPathEffect)) {
+    declareCornerPathEffect(ctx, command.props);
+  } else if (isPathEffect(command, NodeType.SumPathEffect)) {
+    declareSumPathEffect(ctx);
+  } else if (isPathEffect(command, NodeType.Line2DPathEffect)) {
+    declareLine2DPathEffect(ctx, command.props);
+  } else {
+    throw new Error("Invalid image filter type: " + command.imageFilterType);
+  }
+};

package/src/sksg/{nodes/shaders.ts → Recorder/commands/Shaders.ts}

@@ -5,8 +5,10 @@ import {
   processGradientProps,
   processTransformProps,
   rect2rect,
-} from "../../dom/nodes";
+} from "../../../dom/nodes";
+import { NodeType } from "../../../dom/types";
 import type {
+  BlendProps,
   ColorProps,
   FractalNoiseProps,
   ImageShaderProps,
@@ -16,40 +18,41 @@ import type {
   SweepGradientProps,
   TurbulenceProps,
   TwoPointConicalGradientProps,
-} from "../../dom/types";
+} from "../../../dom/types";
 import {
+  BlendMode,
   FilterMode,
   MipmapMode,
   processUniforms,
   TileMode,
-} from "../../skia/types";
-import type { DeclarationContext } from "../DeclarationContext";
+} from "../../../skia/types";
+import { composeDeclarations } from "../../utils";
+import type { Command } from "../Core";
+import { CommandType } from "../Core";
+import type { DrawingContext } from "../DrawingContext";
 
-export const declareShader = (ctx: DeclarationContext, props: ShaderProps) => {
+const declareShader = (ctx: DrawingContext, props: ShaderProps) => {
   "worklet";
   const { source, uniforms, ...transform } = props;
   const m3 = ctx.Skia.Matrix();
   processTransformProps(m3, transform);
   const shader = source.makeShaderWithChildren(
     processUniforms(source, uniforms),
-    ctx.shaders.popAll(),
+    ctx.shaders.splice(0, ctx.shaders.length),
     m3
   );
   ctx.shaders.push(shader);
 };
 
-export const declareColorShader = (
-  ctx: DeclarationContext,
-  props: ColorProps
-) => {
+const declareColorShader = (ctx: DrawingContext, props: ColorProps) => {
   "worklet";
   const { color } = props;
   const shader = ctx.Skia.Shader.MakeColor(ctx.Skia.Color(color));
   ctx.shaders.push(shader);
 };
 
-export const declareFractalNoiseShader = (
-  ctx: DeclarationContext,
+const declareFractalNoiseShader = (
+  ctx: DrawingContext,
   props: FractalNoiseProps
 ) => {
   "worklet";
@@ -65,8 +68,8 @@ export const declareFractalNoiseShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareTwoPointConicalGradientShader = (
-  ctx: DeclarationContext,
+const declareTwoPointConicalGradientShader = (
+  ctx: DrawingContext,
   props: TwoPointConicalGradientProps
 ) => {
   "worklet";
@@ -89,8 +92,8 @@ export const declareTwoPointConicalGradientShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareRadialGradientShader = (
-  ctx: DeclarationContext,
+const declareRadialGradientShader = (
+  ctx: DrawingContext,
   props: RadialGradientProps
 ) => {
   "worklet";
@@ -111,8 +114,8 @@ export const declareRadialGradientShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareSweepGradientShader = (
-  ctx: DeclarationContext,
+const declareSweepGradientShader = (
+  ctx: DrawingContext,
   props: SweepGradientProps
 ) => {
   "worklet";
@@ -135,8 +138,8 @@ export const declareSweepGradientShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareLinearGradientShader = (
-  ctx: DeclarationContext,
+const declareLinearGradientShader = (
+  ctx: DrawingContext,
   props: LinearGradientProps
 ) => {
   "worklet";
@@ -157,8 +160,8 @@ export const declareLinearGradientShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareTurbulenceShader = (
-  ctx: DeclarationContext,
+const declareTurbulenceShader = (
+  ctx: DrawingContext,
   props: TurbulenceProps
 ) => {
   "worklet";
@@ -174,10 +177,7 @@ export const declareTurbulenceShader = (
   ctx.shaders.push(shader);
 };
 
-export const declareImageShader = (
-  ctx: DeclarationContext,
-  props: ImageShaderProps
-) => {
+const declareImageShader = (ctx: DrawingContext, props: ImageShaderProps) => {
   "worklet";
   const { fit, image, tx, ty, fm, mm, ...imageShaderProps } = props;
   if (!image) {
@@ -208,3 +208,77 @@ export const declareImageShader = (
   );
   ctx.shaders.push(shader);
 };
+
+const declareBlend = (ctx: DrawingContext, props: BlendProps) => {
+  "worklet";
+  const blend = BlendMode[enumKey(props.mode as BlendProps["mode"])];
+  const shaders = ctx.shaders.splice(0, ctx.shaders.length);
+  if (shaders.length > 0) {
+    const composer = ctx.Skia.Shader.MakeBlend.bind(ctx.Skia.Shader, blend);
+    ctx.shaders.push(composeDeclarations(shaders, composer));
+  }
+};
+
+export const isPushShader = (
+  command: Command
+): command is Command<CommandType.PushShader> => {
+  "worklet";
+  return command.type === CommandType.PushShader;
+};
+
+type Props = {
+  [NodeType.Shader]: ShaderProps;
+  [NodeType.ImageShader]: ImageShaderProps;
+  [NodeType.ColorShader]: ColorProps;
+  [NodeType.Turbulence]: TurbulenceProps;
+  [NodeType.FractalNoise]: FractalNoiseProps;
+  [NodeType.LinearGradient]: LinearGradientProps;
+  [NodeType.RadialGradient]: RadialGradientProps;
+  [NodeType.SweepGradient]: SweepGradientProps;
+  [NodeType.TwoPointConicalGradient]: TwoPointConicalGradientProps;
+  [NodeType.Blend]: BlendProps;
+};
+
+interface PushShader<T extends keyof Props>
+  extends Command<CommandType.PushShader> {
+  shaderType: T;
+  props: Props[T];
+}
+
+const isShader = <T extends keyof Props>(
+  command: Command<CommandType.PushShader>,
+  type: T
+): command is PushShader<T> => {
+  "worklet";
+  return command.shaderType === type;
+};
+
+export const pushShader = (
+  ctx: DrawingContext,
+  command: Command<CommandType.PushShader>
+) => {
+  "worklet";
+  if (isShader(command, NodeType.Shader)) {
+    declareShader(ctx, command.props);
+  } else if (isShader(command, NodeType.ImageShader)) {
+    declareImageShader(ctx, command.props);
+  } else if (isShader(command, NodeType.ColorShader)) {
+    declareColorShader(ctx, command.props);
+  } else if (isShader(command, NodeType.Turbulence)) {
+    declareTurbulenceShader(ctx, command.props);
+  } else if (isShader(command, NodeType.FractalNoise)) {
+    declareFractalNoiseShader(ctx, command.props);
+  } else if (isShader(command, NodeType.LinearGradient)) {
+    declareLinearGradientShader(ctx, command.props);
+  } else if (isShader(command, NodeType.RadialGradient)) {
+    declareRadialGradientShader(ctx, command.props);
+  } else if (isShader(command, NodeType.SweepGradient)) {
+    declareSweepGradientShader(ctx, command.props);
+  } else if (isShader(command, NodeType.TwoPointConicalGradient)) {
+    declareTwoPointConicalGradientShader(ctx, command.props);
+  } else if (isShader(command, NodeType.Blend)) {
+    declareBlend(ctx, command.props);
+  } else {
+    throw new Error(`Unknown shader type: ${command.shaderType}`);
+  }
+};

package/src/sksg/{nodes/utils.ts → utils.ts}

@@ -1,6 +1,6 @@
 import type { SharedValue } from "react-native-reanimated";
 
-import { mapKeys } from "../../renderer/typeddash";
+import { mapKeys } from "../renderer/typeddash";
 
 export const isSharedValue = <T = unknown>(
   value: unknown
@@ -21,3 +21,16 @@ export const materialize = <T extends object>(props: T) => {
   });
   return result;
 };
+
+type Composer<T> = (outer: T, inner: T) => T;
+
+export const composeDeclarations = <T>(filters: T[], composer: Composer<T>) => {
+  "worklet";
+  const len = filters.length;
+  if (len <= 1) {
+    return filters[0];
+  }
+  return filters.reduceRight((inner, outer) =>
+    inner ? composer(outer, inner) : outer
+  );
+};

package/lib/commonjs/external/reanimated/useDerivedValueOnJS.d.ts

@@ -1 +0,0 @@
-export declare const useDerivedValueOnJS: (fn: () => any, deps: unknown[]) => import("react-native-reanimated").SharedValue<any>;

package/lib/commonjs/external/reanimated/useDerivedValueOnJS.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useDerivedValueOnJS = void 0;
-var _react = require("react");
-var _ReanimatedProxy = _interopRequireDefault(require("./ReanimatedProxy"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const useDerivedValueOnJS = (fn, deps) => {
-  const init = (0, _react.useMemo)(() => fn(), [fn]);
-  const value = _ReanimatedProxy.default.useSharedValue(init);
-  (0, _react.useEffect)(() => {
-    const mapperId = _ReanimatedProxy.default.startMapper(() => {
-      "worklet";
-
-      _ReanimatedProxy.default.runOnJS(fn)();
-    }, deps);
-    return () => _ReanimatedProxy.default.stopMapper(mapperId);
-  }, [deps, fn]);
-  return value;
-};
-exports.useDerivedValueOnJS = useDerivedValueOnJS;
-//# sourceMappingURL=useDerivedValueOnJS.js.map

package/lib/commonjs/external/reanimated/useDerivedValueOnJS.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_ReanimatedProxy","_interopRequireDefault","e","__esModule","default","useDerivedValueOnJS","fn","deps","init","useMemo","value","Rea","useSharedValue","useEffect","mapperId","startMapper","runOnJS","stopMapper","exports"],"sources":["useDerivedValueOnJS.ts"],"sourcesContent":["import { useEffect, useMemo } from \"react\";\n\nimport Rea from \"./ReanimatedProxy\";\n\nexport const useDerivedValueOnJS = (\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  fn: () => any,\n  deps: unknown[]\n) => {\n  const init = useMemo(() => fn(), [fn]);\n  const value = Rea.useSharedValue(init);\n  useEffect(() => {\n    const mapperId = Rea.startMapper(() => {\n      \"worklet\";\n      Rea.runOnJS(fn)();\n    }, deps);\n    return () => Rea.stopMapper(mapperId);\n  }, [deps, fn]);\n  return value;\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,gBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAAoC,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE7B,MAAMG,mBAAmB,GAAGA,CAEjCC,EAAa,EACbC,IAAe,KACZ;EACH,MAAMC,IAAI,GAAG,IAAAC,cAAO,EAAC,MAAMH,EAAE,CAAC,CAAC,EAAE,CAACA,EAAE,CAAC,CAAC;EACtC,MAAMI,KAAK,GAAGC,wBAAG,CAACC,cAAc,CAACJ,IAAI,CAAC;EACtC,IAAAK,gBAAS,EAAC,MAAM;IACd,MAAMC,QAAQ,GAAGH,wBAAG,CAACI,WAAW,CAAC,MAAM;MACrC,SAAS;;MACTJ,wBAAG,CAACK,OAAO,CAACV,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC,EAAEC,IAAI,CAAC;IACR,OAAO,MAAMI,wBAAG,CAACM,UAAU,CAACH,QAAQ,CAAC;EACvC,CAAC,EAAE,CAACP,IAAI,EAAED,EAAE,CAAC,CAAC;EACd,OAAOI,KAAK;AACd,CAAC;AAACQ,OAAA,CAAAb,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/lib/commonjs/sksg/DeclarationContext.d.ts

@@ -1,56 +0,0 @@
-import type { SkShader, SkPaint, SkImageFilter, SkMaskFilter, SkPathEffect, Skia, SkColorFilter } from "../skia/types";
-type Composer<T> = (outer: T, inner: T) => T;
-export declare const composeDeclarations: <T>(filters: T[], composer: Composer<T>) => T;
-export declare const createDeclarationContext: (Skia: Skia) => {
-    Skia: Skia;
-    paints: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkPaint | undefined;
-        push: (decl: SkPaint) => void;
-        popAll: () => SkPaint[];
-        popAllAsOne: () => SkPaint | undefined;
-    };
-    maskFilters: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkMaskFilter | undefined;
-        push: (decl: SkMaskFilter) => void;
-        popAll: () => SkMaskFilter[];
-        popAllAsOne: () => SkMaskFilter | undefined;
-    };
-    shaders: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkShader | undefined;
-        push: (decl: SkShader) => void;
-        popAll: () => SkShader[];
-        popAllAsOne: () => SkShader | undefined;
-    };
-    pathEffects: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkPathEffect | undefined;
-        push: (decl: SkPathEffect) => void;
-        popAll: () => SkPathEffect[];
-        popAllAsOne: () => SkPathEffect | undefined;
-    };
-    imageFilters: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkImageFilter | undefined;
-        push: (decl: SkImageFilter) => void;
-        popAll: () => SkImageFilter[];
-        popAllAsOne: () => SkImageFilter | undefined;
-    };
-    colorFilters: {
-        save: () => void;
-        restore: () => void;
-        pop: () => SkColorFilter | undefined;
-        push: (decl: SkColorFilter) => void;
-        popAll: () => SkColorFilter[];
-        popAllAsOne: () => SkColorFilter | undefined;
-    };
-};
-export type DeclarationContext = ReturnType<typeof createDeclarationContext>;
-export {};

package/lib/commonjs/sksg/DeclarationContext.js

@@ -1,77 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createDeclarationContext = exports.composeDeclarations = void 0;
-const composeDeclarations = (filters, composer) => {
-  "worklet";
-
-  const len = filters.length;
-  if (len <= 1) {
-    return filters[0];
-  }
-  return filters.reduceRight((inner, outer) => inner ? composer(outer, inner) : outer);
-};
-exports.composeDeclarations = composeDeclarations;
-const createDeclaration = composer => {
-  "worklet";
-
-  const state = {
-    decls: [],
-    indexes: [0]
-  };
-  return {
-    save: () => {
-      state.indexes.push(state.decls.length);
-    },
-    restore: () => {
-      state.indexes.pop();
-    },
-    pop: () => state.decls.pop(),
-    push: decl => {
-      state.decls.push(decl);
-    },
-    popAll: () => {
-      const idx = state.indexes[state.indexes.length - 1];
-      return state.decls.splice(idx, state.decls.length - idx);
-    },
-    popAllAsOne: () => {
-      if (state.decls.length === 0) {
-        return undefined;
-      }
-      if (!composer) {
-        throw new Error("No composer for this type of declaration");
-      }
-      if (!state.decls.length) {
-        return undefined;
-      }
-      if (!composer) {
-        throw new Error("No composer for this type of declaration");
-      }
-      const idx = state.indexes[state.indexes.length - 1];
-      const decls = state.decls.splice(idx, state.decls.length - idx);
-      return composeDeclarations(decls, composer);
-    }
-  };
-};
-const createDeclarationContext = Skia => {
-  "worklet";
-
-  const composers = {
-    pathEffect: Skia.PathEffect.MakeCompose.bind(Skia.PathEffect),
-    imageFilter: Skia.ImageFilter.MakeCompose.bind(Skia.ImageFilter),
-    colorFilter: Skia.ColorFilter.MakeCompose.bind(Skia.ColorFilter)
-  };
-  return {
-    Skia,
-    paints: createDeclaration(),
-    maskFilters: createDeclaration(),
-    shaders: createDeclaration(),
-    pathEffects: createDeclaration(composers.pathEffect),
-    imageFilters: createDeclaration(composers.imageFilter),
-    colorFilters: createDeclaration(composers.colorFilter)
-  };
-};
-exports.createDeclarationContext = createDeclarationContext;
-//# sourceMappingURL=DeclarationContext.js.map

package/lib/commonjs/sksg/DeclarationContext.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["composeDeclarations","filters","composer","len","length","reduceRight","inner","outer","exports","createDeclaration","state","decls","indexes","save","push","restore","pop","decl","popAll","idx","splice","popAllAsOne","undefined","Error","createDeclarationContext","Skia","composers","pathEffect","PathEffect","MakeCompose","bind","imageFilter","ImageFilter","colorFilter","ColorFilter","paints","maskFilters","shaders","pathEffects","imageFilters","colorFilters"],"sources":["DeclarationContext.ts"],"sourcesContent":["import type {\n  SkShader,\n  SkPaint,\n  SkImageFilter,\n  SkMaskFilter,\n  SkPathEffect,\n  Skia,\n  SkColorFilter,\n} from \"../skia/types\";\n\ntype Composer<T> = (outer: T, inner: T) => T;\n\nexport const composeDeclarations = <T>(filters: T[], composer: Composer<T>) => {\n  \"worklet\";\n  const len = filters.length;\n  if (len <= 1) {\n    return filters[0];\n  }\n  return filters.reduceRight((inner, outer) =>\n    inner ? composer(outer, inner) : outer\n  );\n};\n\nconst createDeclaration = <T>(composer?: Composer<T>) => {\n  \"worklet\";\n  const state = {\n    decls: [] as T[],\n    indexes: [0],\n  };\n\n  return {\n    save: () => {\n      state.indexes.push(state.decls.length);\n    },\n    restore: () => {\n      state.indexes.pop();\n    },\n    pop: () => state.decls.pop(),\n    push: (decl: T) => {\n      state.decls.push(decl);\n    },\n    popAll: () => {\n      const idx = state.indexes[state.indexes.length - 1];\n      return state.decls.splice(idx, state.decls.length - idx);\n    },\n    popAllAsOne: () => {\n      if (state.decls.length === 0) {\n        return undefined;\n      }\n      if (!composer) {\n        throw new Error(\"No composer for this type of declaration\");\n      }\n      if (!state.decls.length) {\n        return undefined;\n      }\n      if (!composer) {\n        throw new Error(\"No composer for this type of declaration\");\n      }\n\n      const idx = state.indexes[state.indexes.length - 1];\n      const decls = state.decls.splice(idx, state.decls.length - idx);\n      return composeDeclarations(decls, composer);\n    },\n  };\n};\n\nexport const createDeclarationContext = (Skia: Skia) => {\n  \"worklet\";\n  const composers = {\n    pathEffect: Skia.PathEffect.MakeCompose.bind(Skia.PathEffect),\n    imageFilter: Skia.ImageFilter.MakeCompose.bind(Skia.ImageFilter),\n    colorFilter: Skia.ColorFilter.MakeCompose.bind(Skia.ColorFilter),\n  };\n  return {\n    Skia,\n    paints: createDeclaration<SkPaint>(),\n    maskFilters: createDeclaration<SkMaskFilter>(),\n    shaders: createDeclaration<SkShader>(),\n    pathEffects: createDeclaration<SkPathEffect>(composers.pathEffect),\n    imageFilters: createDeclaration<SkImageFilter>(composers.imageFilter),\n    colorFilters: createDeclaration<SkColorFilter>(composers.colorFilter),\n  };\n};\n\nexport type DeclarationContext = ReturnType<typeof createDeclarationContext>;\n"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/sksg/DrawingContext.d.ts

@@ -1,13 +0,0 @@
-import type { DrawingNodeProps, GroupProps } from "../dom/types";
-import type { SkCanvas, Skia, SkPaint } from "../skia/types";
-import type { DeclarationContext } from "./DeclarationContext";
-export declare const createDrawingContext: (Skia: Skia, canvas: SkCanvas) => {
-    Skia: Skia;
-    canvas: SkCanvas;
-    save: () => number;
-    restore: () => SkPaint | undefined;
-    getPaint: () => SkPaint;
-    processPaint: ({ opacity, color, strokeWidth, blendMode, style, strokeJoin, strokeCap, strokeMiter, antiAlias, dither, paint: paintProp, }: DrawingNodeProps, declCtx: DeclarationContext) => boolean;
-    processMatrixAndClipping: (props: GroupProps, layer?: boolean | SkPaint) => boolean;
-};
-export type DrawingContext = ReturnType<typeof createDrawingContext>;