@remotion/svg-3d-engine 4.0.363 → 4.0.365

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@remotion/svg-3d-engine",
 	"dependencies": {
-		"@remotion/paths": "4.0.363"
+		"@remotion/paths": "4.0.365"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.363",
+		"@remotion/eslint-config-internal": "4.0.365",
 		"eslint": "9.19.0"
 	},
 	"main": "dist/cjs/index.js",
@@ -23,7 +23,7 @@
 			"require": "./dist/cjs/index.js"
 		}
 	},
-	"version": "4.0.363",
+	"version": "4.0.365",
 	"repository": {
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/svg-3d-engine"
 	},

package/.turbo/turbo-lint.log

@@ -1,15 +0,0 @@
-
-$ eslint src
-=============
-
-WARNING: You are currently running a version of TypeScript which is not officially supported by @typescript-eslint/typescript-estree.
-
-You may find that it works just fine, or you may not.
-
-SUPPORTED TYPESCRIPT VERSIONS: >=4.7.4 <5.7.0
-
-YOUR TYPESCRIPT VERSION: 5.8.2
-
-Please only submit bug reports when using the officially supported version.
-
-=============

package/.turbo/turbo-make.log

@@ -1,3 +0,0 @@
-
-$ tsc -d && bun --env-file=../.env.bundle bundle.ts
-Generated.

package/bundle.ts

@@ -1,23 +0,0 @@
-import {build} from 'bun';
-
-if (process.env.NODE_ENV !== 'production') {
-	throw new Error('This script must be run using NODE_ENV=production');
-}
-
-const output = await build({
-	entrypoints: ['src/index.ts'],
-	naming: '[name].mjs',
-	external: ['remotion', 'remotion/no-react'],
-});
-
-if (!output.success) {
-	throw new Error(output.logs.join('\n'));
-}
-
-const [file] = output.outputs;
-const text = await file.text();
-
-await Bun.write('dist/esm/index.mjs', text);
-
-export {};
-console.log('Generated.');

package/eslint.config.mjs

@@ -1,7 +0,0 @@
-import {remotionFlatConfig} from '@remotion/eslint-config-internal';
-
-const config = remotionFlatConfig({react: false});
-
-export default {
-	...config,
-};

package/src/3d-svg.ts

@@ -1,59 +0,0 @@
-import type {Vector4D} from './matrix';
-
-export type ThreeDReducedInstruction =
-	| {
-			type: 'M';
-			point: Vector4D;
-	  }
-	| {
-			type: 'L';
-			point: Vector4D;
-	  }
-	| {
-			type: 'C';
-			cp1: Vector4D;
-			cp2: Vector4D;
-			point: Vector4D;
-	  }
-	| {
-			type: 'Q';
-			cp: Vector4D;
-			point: Vector4D;
-	  }
-	| {
-			type: 'Z';
-			point: Vector4D;
-	  };
-
-export const serializeThreeDReducedInstruction = (
-	instruction: ThreeDReducedInstruction,
-): string => {
-	if (instruction.type === 'M') {
-		return `M ${instruction.point[0]} ${instruction.point[1]}`;
-	}
-
-	if (instruction.type === 'L') {
-		return `L ${instruction.point[0]} ${instruction.point[1]}`;
-	}
-
-	if (instruction.type === 'C') {
-		return `C ${instruction.cp1[0]} ${instruction.cp1[1]} ${instruction.cp2[0]} ${instruction.cp2[1]} ${instruction.point[0]} ${instruction.point[1]}`;
-	}
-
-	if (instruction.type === 'Q') {
-		return `Q ${instruction.cp[0]} ${instruction.cp[1]} ${instruction.point[0]} ${instruction.point[1]}`;
-	}
-
-	if (instruction.type === 'Z') {
-		return 'Z';
-	}
-
-	throw new Error('Unknown instruction type');
-};
-
-export const threeDIntoSvgPath = (
-	instructions: ThreeDReducedInstruction[],
-): string =>
-	instructions
-		.map((instruction) => serializeThreeDReducedInstruction(instruction))
-		.join(' ');

package/src/elements.ts

@@ -1,18 +0,0 @@
-import type {FaceType} from './map-face';
-import {transformFace} from './map-face';
-import type {MatrixTransform4D} from './matrix';
-
-export type ThreeDElement = {
-	faces: FaceType[];
-	id: string;
-	description: string;
-};
-
-export const transformFaces = (
-	faces: FaceType[],
-	transformations: MatrixTransform4D[],
-): FaceType[] => {
-	return faces.map((face) => {
-		return transformFace(face, transformations);
-	});
-};

package/src/extrude-element.ts

@@ -1,147 +0,0 @@
-import type {Instruction} from '@remotion/paths';
-import type {ThreeDReducedInstruction} from './3d-svg';
-import {turnInto3D} from './fix-z';
-import type {FaceType} from './map-face';
-import {transformFace, translateSvgInstruction} from './map-face';
-import type {MatrixTransform4D, Vector4D} from './matrix';
-import {translateZ} from './matrix';
-import {subdivideInstructions} from './subdivide-instructions';
-import {truthy} from './truthy';
-
-const inverseInstruction = (
-	instruction: ThreeDReducedInstruction,
-	comingFrom: Vector4D,
-): ThreeDReducedInstruction => {
-	if (instruction.type === 'M') {
-		return {
-			type: 'M',
-			point: comingFrom,
-		};
-	}
-
-	if (instruction.type === 'L') {
-		return {
-			type: 'L',
-			point: comingFrom,
-		};
-	}
-
-	if (instruction.type === 'C') {
-		return {
-			type: 'C',
-			point: comingFrom,
-			cp1: instruction.cp2,
-			cp2: instruction.cp1,
-		};
-	}
-
-	if (instruction.type === 'Q') {
-		return {
-			type: 'Q',
-			point: comingFrom,
-			cp: instruction.cp,
-		};
-	}
-
-	if (instruction.type === 'Z') {
-		return {
-			type: 'L',
-			point: comingFrom,
-		};
-	}
-
-	throw new Error('Unknown instruction type');
-};
-
-type ExtrudeElementOptions = {
-	depth: number;
-	sideColor: string;
-	points: Instruction[];
-	description?: string;
-	crispEdges: boolean;
-};
-
-export const extrudeElement = ({
-	depth,
-	sideColor,
-	points,
-	crispEdges,
-}: ExtrudeElementOptions): FaceType[] => {
-	const threeD = turnInto3D(points);
-	const instructions: FaceType = {
-		centerPoint: [0, 0, 0, 1],
-		points: subdivideInstructions(
-			subdivideInstructions(subdivideInstructions(threeD)),
-		),
-		color: 'black',
-		crispEdges,
-	};
-
-	const unscaledBackFace = transformFace(instructions, [translateZ(depth / 2)]);
-
-	const inbetween = unscaledBackFace.points.map((t, i): FaceType => {
-		const nextInstruction =
-			i === unscaledBackFace.points.length - 1
-				? unscaledBackFace.points[0]
-				: unscaledBackFace.points[i + 1];
-
-		const currentPoint = t.point;
-		const nextPoint = nextInstruction.point;
-		const movingOver: Vector4D = [
-			nextPoint[0],
-			nextPoint[1],
-			nextPoint[2] - depth,
-			nextPoint[3],
-		];
-
-		const translatedInstruction = translateSvgInstruction(
-			inverseInstruction(nextInstruction, currentPoint),
-			0,
-			0,
-			-depth,
-		);
-		const newInstructions: ThreeDReducedInstruction[] = [
-			{
-				type: 'M' as const,
-				point: currentPoint,
-			},
-			nextInstruction,
-			nextInstruction.type === 'Z'
-				? {
-						type: 'M' as const,
-						point: nextInstruction.point,
-					}
-				: null,
-			{
-				type: 'L' as const,
-				point: movingOver,
-			},
-			translatedInstruction,
-			{
-				type: 'L' as const,
-				point: currentPoint,
-			},
-		].filter(truthy);
-
-		return {
-			points: newInstructions,
-			color: sideColor,
-			centerPoint: [0, 0, 0, 1],
-			crispEdges: true,
-		};
-	});
-
-	return inbetween;
-};
-
-export const extrudeAndTransformElement = (
-	options: ExtrudeElementOptions & {
-		transformations: MatrixTransform4D;
-	},
-): FaceType[] => {
-	const inbetween = extrudeElement(options);
-
-	return inbetween.map((face) => ({
-		...transformFace(face, [options.transformations]),
-	}));
-};

package/src/fix-z.ts

@@ -1,45 +0,0 @@
-import type {Instruction} from '@remotion/paths';
-import {reduceInstructions} from '@remotion/paths';
-import type {ThreeDReducedInstruction} from './3d-svg';
-import type {Vector4D} from './matrix';
-
-export const turnInto3D = (
-	instructions: Instruction[],
-): ThreeDReducedInstruction[] => {
-	let lastMove: Vector4D = [0, 0, 0, 1];
-	const newInstructions: ThreeDReducedInstruction[] = [];
-	const reduced = reduceInstructions(instructions);
-
-	for (let i = 0; i < reduced.length; i++) {
-		const instruction = reduced[i];
-
-		if (instruction.type === 'Z') {
-			newInstructions.push({
-				type: 'Z',
-				point: lastMove,
-			});
-		} else if (instruction.type === 'M') {
-			lastMove = [instruction.x, instruction.y, 0, 1];
-			newInstructions.push({
-				point: [instruction.x, instruction.y, 0, 1],
-				type: 'M',
-			});
-		} else if (instruction.type === 'L') {
-			newInstructions.push({
-				type: 'L',
-				point: [instruction.x, instruction.y, 0, 1],
-			});
-		} else if (instruction.type === 'C') {
-			newInstructions.push({
-				type: 'C',
-				point: [instruction.x, instruction.y, 0, 1],
-				cp1: [instruction.cp1x, instruction.cp1y, 0, 1],
-				cp2: [instruction.cp2x, instruction.cp2y, 0, 1],
-			});
-		} else {
-			throw new Error('unknown');
-		}
-	}
-
-	return newInstructions;
-};

package/src/index.ts

@@ -1,22 +0,0 @@
-export {MatrixTransform4D, Vector4D} from './matrix';
-
-export type {ThreeDReducedInstruction} from './3d-svg';
-
-export {threeDIntoSvgPath} from './3d-svg';
-export {extrudeAndTransformElement, extrudeElement} from './extrude-element';
-export {transformPath, type FaceType} from './map-face';
-export {
-	aroundCenterPoint,
-	interpolateMatrix4d,
-	makeMatrix3dTransform,
-	reduceMatrices,
-	rotateX,
-	rotateY,
-	rotateZ,
-	scaleX,
-	scaleY,
-	scaled,
-	translateX,
-	translateY,
-	translateZ,
-} from './matrix';

package/src/make-id.ts

@@ -1,3 +0,0 @@
-export const makeId = () => {
-	return Math.random().toString().replace('.', '');
-};

package/src/map-face.ts

@@ -1,167 +0,0 @@
-import {parsePath, reduceInstructions} from '@remotion/paths';
-import {threeDIntoSvgPath, type ThreeDReducedInstruction} from './3d-svg';
-import {turnInto3D} from './fix-z';
-import type {MatrixTransform4D, Vector4D} from './matrix';
-import {multiplyMatrix, multiplyMatrixAndSvgInstruction} from './matrix';
-
-export type FaceType = {
-	color: string;
-	points: ThreeDReducedInstruction[];
-	centerPoint: Vector4D;
-	crispEdges: boolean;
-};
-
-export const translateSvgInstruction = (
-	instruction: ThreeDReducedInstruction,
-	x: number,
-	y: number,
-	z: number,
-): ThreeDReducedInstruction => {
-	if (instruction.type === 'M') {
-		return {
-			type: 'M',
-			point: [
-				instruction.point[0] + x,
-				instruction.point[1] + y,
-				instruction.point[2] + z,
-				instruction.point[3],
-			],
-		};
-	}
-
-	if (instruction.type === 'L') {
-		return {
-			type: 'L',
-			point: [
-				instruction.point[0] + x,
-				instruction.point[1] + y,
-				instruction.point[2] + z,
-				instruction.point[3],
-			],
-		};
-	}
-
-	if (instruction.type === 'C') {
-		return {
-			type: 'C',
-			point: [
-				instruction.point[0] + x,
-				instruction.point[1] + y,
-				instruction.point[2] + z,
-				instruction.point[3],
-			],
-			cp1: [
-				instruction.cp1[0] + x,
-				instruction.cp1[1] + y,
-				instruction.cp1[2] + z,
-				instruction.cp1[3],
-			],
-			cp2: [
-				instruction.cp2[0] + x,
-				instruction.cp2[1] + y,
-				instruction.cp2[2] + z,
-				instruction.cp2[3],
-			],
-		};
-	}
-
-	if (instruction.type === 'Q') {
-		return {
-			type: 'Q',
-			point: [
-				instruction.point[0] + x,
-				instruction.point[1] + y,
-				instruction.point[2] + z,
-				instruction.point[3],
-			],
-			cp: [
-				instruction.cp[0] + x,
-				instruction.cp[1] + y,
-				instruction.cp[2] + z,
-				instruction.cp[3],
-			],
-		};
-	}
-
-	if (instruction.type === 'Z') {
-		return {
-			type: 'Z',
-			point: [
-				instruction.point[0] + x,
-				instruction.point[1] + y,
-				instruction.point[2] + z,
-				instruction.point[3],
-			],
-		};
-	}
-
-	throw new Error('Unknown instruction type: ' + JSON.stringify(instruction));
-};
-
-export const transformPath = ({
-	path,
-	transformation,
-}: {
-	path: string;
-	transformation: MatrixTransform4D;
-}): string => {
-	const parsed = parsePath(path);
-	const reduced = reduceInstructions(parsed);
-	const threeD = turnInto3D(reduced);
-	return threeDIntoSvgPath(
-		threeD.map((p) => {
-			return multiplyMatrixAndSvgInstruction(transformation, p);
-		}),
-	);
-};
-
-export const transformFace = (
-	face: FaceType,
-	transformations: MatrixTransform4D[],
-): FaceType => {
-	return {
-		...face,
-		points: face.points.map((p) => {
-			return transformations.reduce((acc, t) => {
-				return multiplyMatrixAndSvgInstruction(t, acc);
-			}, p);
-		}),
-		centerPoint: transformations.reduce((acc, t) => {
-			const result = multiplyMatrix(t, acc);
-			return result;
-		}, face.centerPoint),
-	};
-};
-
-export const transformFaces = ({
-	faces,
-	transformations,
-}: {
-	faces: FaceType[];
-	transformations: MatrixTransform4D[];
-}) => {
-	return faces.map((face) => {
-		return transformFace(face, transformations);
-	});
-};
-
-export const makeFace = ({
-	points,
-	fill,
-	crispEdges,
-}: {
-	points: string | ThreeDReducedInstruction[];
-	strokeWidth: number;
-	strokeColor: string;
-	fill: string;
-	crispEdges: boolean;
-}): FaceType => {
-	const centerPoint: Vector4D = [0, 0, 0, 1];
-
-	return {
-		centerPoint,
-		color: fill,
-		points: typeof points === 'string' ? turnInto3D(parsePath(points)) : points,
-		crispEdges,
-	};
-};