@junwan666/remotion-captions 4.0.448-zh.0

package/README.md

@@ -0,0 +1,18 @@
+# @remotion/captions
+
+Primitives for dealing with captions
+
+[![NPM Downloads](https://img.shields.io/npm/dm/@remotion/captions.svg?style=flat&color=black&label=Downloads)](https://npmcharts.com/compare/@remotion/captions?minimal=true)
+
+## Installation
+
+```bash
+npm install @remotion/captions --save-exact
+```
+
+When installing a Remotion package, make sure to align the version of all `remotion` and `@remotion/*` packages to the same version.
+Remove the `^` character from the version number to use the exact version.
+
+## Usage
+
+See the [documentation](https://remotion.dev/docs/captions/api) for more information.

package/dist/caption.d.ts

@@ -0,0 +1,7 @@
+export type Caption = {
+    text: string;
+    startMs: number;
+    endMs: number;
+    timestampMs: number | null;
+    confidence: number | null;
+};

package/dist/caption.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/create-tiktok-style-captions.d.ts

@@ -0,0 +1,20 @@
+import type { Caption } from './caption';
+export type TikTokToken = {
+    text: string;
+    fromMs: number;
+    toMs: number;
+};
+export type TikTokPage = {
+    text: string;
+    startMs: number;
+    tokens: TikTokToken[];
+    durationMs: number;
+};
+export type CreateTikTokStyleCaptionsInput = {
+    captions: Caption[];
+    combineTokensWithinMilliseconds: number;
+};
+export type CreateTikTokStyleCaptionsOutput = {
+    pages: TikTokPage[];
+};
+export declare const createTikTokStyleCaptions: ({ captions, combineTokensWithinMilliseconds, }: CreateTikTokStyleCaptionsInput) => CreateTikTokStyleCaptionsOutput;

package/dist/create-tiktok-style-captions.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTikTokStyleCaptions = void 0;
+const createTikTokStyleCaptions = ({ captions, combineTokensWithinMilliseconds, }) => {
+    const tikTokStyleCaptions = [];
+    let currentText = '';
+    let currentTokens = [];
+    let currentFrom = 0;
+    let currentTo = 0;
+    const add = () => {
+        tikTokStyleCaptions.push({
+            text: currentText.trimStart(),
+            startMs: currentFrom,
+            tokens: currentTokens,
+            durationMs: Infinity,
+        });
+        if (tikTokStyleCaptions.length > 1) {
+            tikTokStyleCaptions[tikTokStyleCaptions.length - 2].durationMs =
+                currentFrom -
+                    tikTokStyleCaptions[tikTokStyleCaptions.length - 2].startMs;
+        }
+    };
+    captions.forEach((item, index) => {
+        const { text } = item;
+        // If text starts with a space, push the currentText (if it exists) and start a new one
+        if (text.startsWith(' ') &&
+            currentTo - currentFrom > combineTokensWithinMilliseconds) {
+            if (currentText !== '') {
+                add();
+            }
+            // Start a new sentence
+            currentText = text.trimStart();
+            currentTokens = [
+                { text: currentText, fromMs: item.startMs, toMs: item.endMs },
+            ].filter((t) => t.text !== '');
+            currentFrom = item.startMs;
+            currentTo = item.endMs;
+        }
+        else {
+            // Continuation or start of a new sentence without leading space
+            if (currentText === '') {
+                // It's the start of the document or after a sentence that started with a space
+                currentFrom = item.startMs;
+            }
+            currentText += text;
+            currentText = currentText.trimStart();
+            if (text.trim() !== '') {
+                currentTokens.push({
+                    text: currentTokens.length === 0 ? currentText.trimStart() : text,
+                    fromMs: item.startMs,
+                    toMs: item.endMs,
+                });
+            }
+            currentTo = item.endMs;
+        }
+        // Ensure the last sentence is added
+        if (index === captions.length - 1 && currentText !== '') {
+            add();
+            tikTokStyleCaptions[tikTokStyleCaptions.length - 1].durationMs =
+                currentTo - tikTokStyleCaptions[tikTokStyleCaptions.length - 1].startMs;
+        }
+    });
+    return { pages: tikTokStyleCaptions };
+};
+exports.createTikTokStyleCaptions = createTikTokStyleCaptions;

package/dist/ensure-max-characters-per-line.d.ts

@@ -0,0 +1,9 @@
+import type { Caption } from './caption';
+export type EnsureMaxCharactersPerLineInput = {
+    captions: Caption[];
+    maxCharsPerLine: number;
+};
+export type EnsureMaxCharactersPerLineOutput = {
+    segments: Caption[][];
+};
+export declare const ensureMaxCharactersPerLine: ({ captions, maxCharsPerLine, }: EnsureMaxCharactersPerLineInput) => EnsureMaxCharactersPerLineOutput;

package/dist/ensure-max-characters-per-line.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureMaxCharactersPerLine = void 0;
+const splitWords = (inputCaptions) => {
+    const captions = [];
+    for (let i = 0; i < inputCaptions.length; i++) {
+        const w = inputCaptions[i];
+        const words = w.text.split(' ');
+        for (let j = 0; j < words.length; j++) {
+            const word = words[j];
+            captions.push({
+                text: j === 0 ? ` ${word}` : word,
+                startMs: w.startMs,
+                endMs: w.endMs,
+                confidence: w.confidence,
+                timestampMs: w.timestampMs,
+            });
+        }
+    }
+    return captions;
+};
+const ensureMaxCharactersPerLine = ({ captions, maxCharsPerLine, }) => {
+    const splitted = splitWords(captions);
+    const segments = [];
+    let currentSegment = [];
+    for (let i = 0; i < splitted.length; i++) {
+        const w = splitted[i];
+        const remainingWords = splitted.slice(i + 1);
+        const filledCharactersInLine = currentSegment
+            .map((s) => s.text.length)
+            .reduce((a, b) => a + b, 0);
+        const preventOrphanWord = remainingWords.length < 4 &&
+            remainingWords.length > 1 &&
+            filledCharactersInLine > maxCharsPerLine / 2;
+        if (filledCharactersInLine + w.text.length > maxCharsPerLine ||
+            preventOrphanWord) {
+            segments.push(currentSegment);
+            currentSegment = [];
+        }
+        currentSegment.push(w);
+    }
+    segments.push(currentSegment);
+    return { segments };
+};
+exports.ensureMaxCharactersPerLine = ensureMaxCharactersPerLine;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Caption } from './caption';
+export { createTikTokStyleCaptions, CreateTikTokStyleCaptionsInput, CreateTikTokStyleCaptionsOutput, TikTokPage, TikTokToken, } from './create-tiktok-style-captions';
+export { EnsureMaxCharactersPerLineInput, EnsureMaxCharactersPerLineOutput, } from './ensure-max-characters-per-line';
+export { parseSrt, ParseSrtInput, ParseSrtOutput } from './parse-srt';
+export { serializeSrt, SerializeSrtInput } from './serialize-srt';
+export declare const CaptionsInternals: {
+    ensureMaxCharactersPerLine: ({ captions, maxCharsPerLine, }: import("./ensure-max-characters-per-line").EnsureMaxCharactersPerLineInput) => import("./ensure-max-characters-per-line").EnsureMaxCharactersPerLineOutput;
+};

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptionsInternals = exports.serializeSrt = exports.parseSrt = exports.createTikTokStyleCaptions = void 0;
+const ensure_max_characters_per_line_1 = require("./ensure-max-characters-per-line");
+const create_tiktok_style_captions_1 = require("./create-tiktok-style-captions");
+Object.defineProperty(exports, "createTikTokStyleCaptions", { enumerable: true, get: function () { return create_tiktok_style_captions_1.createTikTokStyleCaptions; } });
+const parse_srt_1 = require("./parse-srt");
+Object.defineProperty(exports, "parseSrt", { enumerable: true, get: function () { return parse_srt_1.parseSrt; } });
+const serialize_srt_1 = require("./serialize-srt");
+Object.defineProperty(exports, "serializeSrt", { enumerable: true, get: function () { return serialize_srt_1.serializeSrt; } });
+exports.CaptionsInternals = {
+    ensureMaxCharactersPerLine: ensure_max_characters_per_line_1.ensureMaxCharactersPerLine,
+};

package/dist/parse-srt.d.ts

@@ -0,0 +1,8 @@
+import type { Caption } from './caption';
+export type ParseSrtInput = {
+    input: string;
+};
+export type ParseSrtOutput = {
+    captions: Caption[];
+};
+export declare const parseSrt: ({ input }: ParseSrtInput) => ParseSrtOutput;

package/dist/parse-srt.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSrt = void 0;
+function toSeconds(time) {
+    const [first, second, third] = time.split(':');
+    if (!first) {
+        throw new Error(`Invalid timestamp:${time}`);
+    }
+    if (!second) {
+        throw new Error(`Invalid timestamp:${time}`);
+    }
+    if (!third) {
+        throw new Error(`Invalid timestamp:${time}`);
+    }
+    const [seconds, millis] = third.split(',');
+    if (!seconds) {
+        throw new Error(`Invalid timestamp:${time}`);
+    }
+    if (!millis) {
+        throw new Error(`Invalid timestamp:${time}`);
+    }
+    return (parseInt(first, 10) * 3600 +
+        parseInt(second, 10) * 60 +
+        parseInt(seconds, 10) +
+        parseInt(millis, 10) / 1000);
+}
+const parseSrt = ({ input }) => {
+    const inputLines = input.split('\n');
+    const captions = [];
+    for (let i = 0; i < inputLines.length; i++) {
+        const line = inputLines[i];
+        const nextLine = inputLines[i + 1];
+        if ((line === null || line === void 0 ? void 0 : line.match(/([0-9]+)/)) && (nextLine === null || nextLine === void 0 ? void 0 : nextLine.includes(' --> '))) {
+            const nextLineSplit = nextLine.split(' --> ');
+            const start = toSeconds(nextLineSplit[0]);
+            const end = toSeconds(nextLineSplit[1]);
+            captions.push({
+                text: '',
+                startMs: start * 1000,
+                endMs: end * 1000,
+                confidence: 1,
+                timestampMs: ((start + end) / 2) * 1000,
+            });
+        }
+        else if (line === null || line === void 0 ? void 0 : line.includes(' --> ')) {
+            continue;
+        }
+        else if ((line === null || line === void 0 ? void 0 : line.trim()) === '') {
+            captions[captions.length - 1].text = captions[captions.length - 1].text.trim();
+        }
+        else {
+            captions[captions.length - 1].text += line + '\n';
+        }
+    }
+    return {
+        captions: captions.map((l) => {
+            return {
+                ...l,
+                text: l.text.trimEnd(),
+            };
+        }),
+    };
+};
+exports.parseSrt = parseSrt;

package/dist/serialize-srt.d.ts

@@ -0,0 +1,5 @@
+import type { Caption } from './caption';
+export type SerializeSrtInput = {
+    lines: Caption[][];
+};
+export declare const serializeSrt: ({ lines }: SerializeSrtInput) => string;

package/dist/serialize-srt.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSrt = void 0;
+const formatSingleSrtTimestamp = (timestamp) => {
+    const hours = Math.floor(timestamp / 3600000);
+    const minutes = Math.floor((timestamp % 3600000) / 60000);
+    const seconds = Math.floor((timestamp % 60000) / 1000);
+    const milliseconds = Math.floor(timestamp % 1000);
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(milliseconds).padStart(3, '0')}`;
+};
+const formatSrtTimestamp = (startMs, endMs) => {
+    return `${formatSingleSrtTimestamp(startMs)} --> ${formatSingleSrtTimestamp(endMs)}`;
+};
+const serializeSrt = ({ lines }) => {
+    let currentIndex = 0;
+    return lines
+        .map((s) => {
+        currentIndex++;
+        if (s.length === 0) {
+            return null;
+        }
+        const firstTimestamp = s[0].startMs;
+        const lastTimestamp = s[s.length - 1].endMs;
+        return [
+            // Index
+            currentIndex,
+            formatSrtTimestamp(firstTimestamp, lastTimestamp),
+            // Text
+            s.map((caption) => caption.text).join(''),
+        ].join('\n');
+    })
+        .filter(Boolean)
+        .join('\n\n');
+};
+exports.serializeSrt = serializeSrt;

package/package.json

@@ -0,0 +1,36 @@
+{
+	"repository": {
+		"url": "https://github.com/JunWan666/remotion-zh/tree/main/packages/captions"
+	},
+	"name": "@junwan666/remotion-captions",
+	"version": "4.0.448-zh.0",
+	"description": "Primitives for dealing with captions",
+	"main": "dist/index.js",
+	"sideEffects": false,
+	"bugs": {
+		"url": "https://github.com/remotion-dev/remotion/issues"
+	},
+	"scripts": {
+		"formatting": "oxfmt src --check",
+		"format": "oxfmt src",
+		"lint": "eslint src",
+		"test": "bun test src",
+		"make": "tsgo -d"
+	},
+	"author": "Jonny Burger <jonny@remotion.dev>",
+	"license": "MIT",
+	"dependencies": {},
+	"peerDependencies": {},
+	"devDependencies": {
+		"@remotion/eslint-config-internal": "npm:@junwan666/remotion-eslint-config-internal@4.0.448-zh.0",
+		"eslint": "9.19.0",
+		"@typescript/native-preview": "7.0.0-dev.20260217.1"
+	},
+	"keywords": [
+		"remotion"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://remotion.dev/docs/captions/api"
+}