effect-libreoffice 1.0.0 → 1.0.5

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright 2025 Filip Weiss
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,5 +1,9 @@
 # effect-libreoffice
 
+[![NPM Version](https://img.shields.io/npm/v/effect-libreoffice)](https://www.npmjs.com/package/effect-libreoffice)
+[![GitHub License](https://img.shields.io/github/license/fiws/effect-libreoffice)](https://github.com/fiws/effect-libreoffice/blob/main/LICENSE)
+[![Effect: yes](https://img.shields.io/badge/effect-yes-blue)](https://effect.website/)
+
 A Effect-based wrapper for LibreOffice, providing multiple strategies for document conversion.
 
 ## Implementations
@@ -11,12 +15,12 @@ This library offers two distinct implementations for interacting with LibreOffic
 
 ### Comparison
 
-| Feature         | LibreOfficeCmd (Default)                 | UnoClient (Uno)                            |
-| :-------------- | :--------------------------------------- | :----------------------------------------- |
-| **Method**      | Spawns a new process for each conversion | Connects to a long-running server          |
-| **Performance** | Slower (~440ms/file)                     | Fast (~60ms/file)                          |
-| **Setup**       | Requires LibreOffice installed locally   | Requires `unoserver`                       |
-| **Best For**    | CLI tools, low volume, simple setup      | Servers, high volume, performance critical |
+| Feature         | LibreOfficeCmd (Default)                 | UnoClient (Uno)                                            |
+| :-------------- | :--------------------------------------- | :--------------------------------------------------------- |
+| **Method**      | Spawns a new process for each conversion | Connects to a long-running server                          |
+| **Performance** | Slower (~440ms/file)                     | Fast (~60ms/file)                                          |
+| **Setup**       | Requires LibreOffice installed locally   | Requires [unoserver](https://github.com/unoconv/unoserver) |
+| **Best For**    | CLI tools, low volume, simple setup      | Servers, high volume, performance critical                 |
 
 ## Usage
 

package/dist/index.d.mts

@@ -0,0 +1,98 @@
+import { FileSystem, HttpClient, HttpClientResponse, Path } from "@effect/platform";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as _effect_platform_Error0 from "@effect/platform/Error";
+import * as _effect_platform_CommandExecutor0 from "@effect/platform/CommandExecutor";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+import * as effect_Scope0 from "effect/Scope";
+import * as _effect_platform_HttpClientError0 from "@effect/platform/HttpClientError";
+import * as effect_ParseResult0 from "effect/ParseResult";
+
+//#region src/shared.d.ts
+type KnownSupportedOutputFormat = "pdf" | "docx" | "doc" | "odt" | "html" | "rtf" | "epub" | "jpg" | "txt";
+type OutputPath = `${string}.${KnownSupportedOutputFormat}` | (string & {});
+type Reason = "InputFileNotFound" | "StartFailed" | "Unknown" | "BadOutputExtension" | "MethodNotFound" | "PermissionDenied";
+declare const LibreOfficeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "LibreOfficeError";
+} & Readonly<A>;
+declare class LibreOfficeError extends LibreOfficeError_base<{
+  reason: Reason;
+  message: string;
+  cause?: unknown;
+}> {}
+//#endregion
+//#region src/uno/uno.d.ts
+declare const UnoError_base: Schema.TaggedErrorClass<UnoError, "UnoError", {
+  readonly _tag: Schema.tag<"UnoError">;
+} & {
+  message: typeof Schema.String;
+  reason: Schema.Literal<["StartFailed", "Unknown", "InputFileNotFound", "BadOutputExtension", "MethodNotFound", "PermissionDenied"]>;
+  cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * Error thrown when the uno server fails to start or when a conversion fails.
+ */
+declare class UnoError extends UnoError_base {}
+declare const UnoServer_base: Effect.Service.Class<UnoServer, "libre-convert-effect/index/UnoServer", {
+  readonly scoped: Effect.Effect<{
+    /**
+     * The url of the uno server
+     */
+    url: string;
+  }, _effect_platform_Error0.PlatformError | UnoError, effect_Scope0.Scope | _effect_platform_CommandExecutor0.CommandExecutor>;
+}>;
+/**
+ * UnoServer service. The default implementation will try to spawn a new `unoserver` process.
+ */
+declare class UnoServer extends UnoServer_base {
+  /**
+   * Note that while any url can be passed, libreoffice will expect the given files
+   * to be on disk and will write them to disk, so to be actually useful the server
+   * should probably utilize the same file system as your process.
+   *
+   * This url can be useful if the uno server is running inside a docker (with a mounted file system)
+   */
+  static remoteWithURL: (url: string) => Layer.Layer<UnoServer, UnoError, never>;
+  /**
+   * Static layer that expects the uno server to be running on localhost:2003
+   */
+  static Remote: Layer.Layer<UnoServer, UnoError, never>;
+}
+declare const UnoClient_base: Effect.Service.Class<UnoClient, "libre-convert-effect/uno/UnoClient", {
+  readonly scoped: Effect.Effect<{
+    client: HttpClient.HttpClient.With<_effect_platform_HttpClientError0.HttpClientError, never>;
+    convert(input: string, output: OutputPath): Effect.Effect<HttpClientResponse.HttpClientResponse, _effect_platform_HttpClientError0.HttpClientError | UnoError | effect_ParseResult0.ParseError, never>;
+    compare(input: string, output: string): Effect.Effect<HttpClientResponse.HttpClientResponse, _effect_platform_HttpClientError0.HttpClientError | UnoError | effect_ParseResult0.ParseError, never>;
+  }, never, HttpClient.HttpClient | UnoServer>;
+}>;
+declare class UnoClient extends UnoClient_base {}
+//#endregion
+//#region src/index.d.ts
+declare const LibreOfficeCmd_base: Context.ReferenceClass<LibreOfficeCmd, "libre-convert-effect/index/LibreOfficeCmd", string[]>;
+declare class LibreOfficeCmd extends LibreOfficeCmd_base {}
+declare const LibreOffice_base: Effect.Service.Class<LibreOffice, "libre-convert-effect/index/LibreOffice", {
+  readonly scoped: Effect.Effect<{
+    /**
+     * Converts a file to a different format.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const program = Effect.gen(function* () {
+     *   const libre = yield* LibreOffice;
+     *   yield* libre.convertLocalFile("/path/to/input.docx", "/path/to/output.pdf");
+     * });
+     * ```
+     */
+    convertLocalFile: (input: string, output: OutputPath) => Effect.Effect<undefined, LibreOfficeError | _effect_platform_Error0.PlatformError, _effect_platform_CommandExecutor0.CommandExecutor>;
+  }, never, FileSystem.FileSystem | Path.Path>;
+}>;
+declare class LibreOffice extends LibreOffice_base {
+  /**
+   * The Uno layer uses a unoserver to convert files. It is much more
+   * performant than the cli but requires a unoserver to be running.
+   */
+  static Uno: Layer.Layer<LibreOffice, never, UnoClient>;
+}
+//#endregion
+export { LibreOffice, LibreOfficeCmd };

package/dist/index.mjs

@@ -0,0 +1,289 @@
+import { Command, FileSystem, HttpClient, HttpClientRequest, Path } from "@effect/platform";
+import { Context, Data, Effect, Layer, Match, Schedule, Schema, Stream, String, flow } from "effect";
+import { XMLParser } from "fast-xml-parser";
+
+//#region src/shared.ts
+var LibreOfficeError = class extends Data.TaggedError("LibreOfficeError") {};
+
+//#endregion
+//#region src/uno/schema-utils.ts
+const MemberValue = Schema.Union(Schema.Struct({ int: Schema.Number }), Schema.Struct({ string: Schema.String }));
+const Member = Schema.Struct({
+	name: Schema.String,
+	value: MemberValue
+});
+const Members = Schema.Array(Member);
+const StructFromMembers = (fields) => Schema.transform(Members, Schema.Struct(fields), {
+	strict: false,
+	decode: (input) => {
+		const output = {};
+		for (const member of input) if ("int" in member.value) output[member.name] = member.value.int;
+		else if ("string" in member.value) output[member.name] = member.value.string;
+		return output;
+	},
+	encode: (input) => {
+		return Object.entries(input).map(([name, value]) => {
+			if (typeof value === "number") return {
+				name,
+				value: { int: value }
+			};
+			if (typeof value === "string") return {
+				name,
+				value: { string: value }
+			};
+			throw new Error(`Unsupported value type for member ${name}: ${typeof value}`);
+		});
+	}
+});
+
+//#endregion
+//#region src/uno/uno-response.ts
+/**
+* Schema for fault response
+*
+* ## Original xml
+* ```xml
+* <?xml version='1.0'?>
+* <methodResponse>
+*   <fault>
+*     <value>
+*       <struct>
+*         <member>
+*           <name>faultCode</name>
+*           <value>
+*             <int>1</int>
+*           </value>
+*         </member>
+*         <member>
+*           <name>faultString</name>
+*           <value>
+*             <string>&lt;class 'RuntimeError'&gt;:Path /tmp/test-convert/test.txt does not exist.</string>
+*           </value>
+*         </member>
+*       </struct>
+*     </value>
+*   </fault>
+* </methodResponse>
+* ```
+*/
+const UnoFault = Schema.Struct({ methodResponse: Schema.Struct({ fault: Schema.Struct({ value: Schema.Struct({ struct: Schema.Struct({ member: StructFromMembers({
+	faultCode: Schema.Number,
+	faultString: Schema.String
+}) }) }) }) }) }).pipe(Schema.transform(Schema.Struct({
+	faultCode: Schema.Number,
+	faultString: Schema.String
+}), {
+	strict: true,
+	decode: (input) => input.methodResponse.fault.value.struct.member,
+	encode: (input) => ({ methodResponse: { fault: { value: { struct: { member: input } } } } })
+}), Schema.asSchema);
+/**
+* Schema for empty response (success)
+*
+* ## Original xml
+* ```xml
+* <?xml version='1.0'?>
+* <methodResponse>
+*   <params>
+*     <param>
+*       <value>
+*         <nil />
+*       </value>
+*     </param>
+*   </params>
+* </methodResponse>
+* ```
+*/
+const UnoEmpty = Schema.Struct({ methodResponse: Schema.Struct({ params: Schema.Struct({ param: Schema.Struct({ value: Schema.Struct({ nil: Schema.String }) }) }) }) }).pipe(Schema.asSchema);
+const UnoResponse = Schema.Union(UnoFault, UnoEmpty);
+const decodeUnoResponse = Schema.decodeUnknown(UnoResponse);
+
+//#endregion
+//#region src/uno/xml-parser.ts
+const parser = new XMLParser();
+function parseXML(input) {
+	return parser.parse(input);
+}
+
+//#endregion
+//#region src/uno/uno.ts
+/**
+* Error thrown when the uno server fails to start or when a conversion fails.
+*/
+var UnoError = class extends Schema.TaggedError()("UnoError", {
+	message: Schema.String,
+	reason: Schema.Literal("StartFailed", "Unknown", "InputFileNotFound", "BadOutputExtension", "MethodNotFound", "PermissionDenied"),
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+const testRunning = Effect.fn(function* (url) {
+	return yield* Effect.tryPromise({
+		try: () => fetch(url, {
+			method: "POST",
+			body: `<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName><params></params></methodCall>`
+		}),
+		catch: (e) => new UnoError({
+			reason: "StartFailed",
+			message: globalThis.String(e)
+		})
+	}).pipe(Effect.flatMap((res) => res.ok ? Effect.void : new UnoError({
+		reason: "StartFailed",
+		message: "Server not ready"
+	})));
+});
+const ensureRunning = flow(testRunning, Effect.retry({
+	times: 40,
+	schedule: Schedule.spaced("250 millis")
+}));
+/**
+* UnoServer service. The default implementation will try to spawn a new `unoserver` process.
+*/
+var UnoServer = class UnoServer extends Effect.Service()("libre-convert-effect/index/UnoServer", { scoped: Effect.gen(function* () {
+	const acquire = Effect.gen(function* () {
+		const process = yield* Command.start(Command.make("unoserver"));
+		yield* ensureRunning(`http://localhost:2003/RPC2`).pipe(Effect.catchAll(() => new UnoError({
+			reason: "StartFailed",
+			message: "Failed to start server"
+		})));
+		return process;
+	});
+	yield* Effect.acquireRelease(acquire, (process) => Effect.ignore(process.kill()));
+	return { url: "http://localhost:2003/RPC2" };
+}) }) {
+	/**
+	* Note that while any url can be passed, libreoffice will expect the given files
+	* to be on disk and will write them to disk, so to be actually useful the server
+	* should probably utilize the same file system as your process.
+	*
+	* This url can be useful if the uno server is running inside a docker (with a mounted file system)
+	*/
+	static remoteWithURL = (url) => Layer.scoped(UnoServer, Effect.gen(function* () {
+		yield* ensureRunning(url);
+		return UnoServer.make({ url });
+	}));
+	/**
+	* Static layer that expects the uno server to be running on localhost:2003
+	*/
+	static Remote = UnoServer.remoteWithURL("http://localhost:2003/RPC2");
+};
+const convertRequest = (input, output) => {
+	const body = `<?xml version="1.0"?>
+<methodCall>
+  <methodName>convert</methodName>
+  <params>
+    <param><value><string>${input}</string></value></param>
+    <param><value><nil/></value></param>
+    <param><value><string>${output}</string></value></param>
+  </params>
+</methodCall>
+`;
+	return HttpClientRequest.post("").pipe(HttpClientRequest.bodyText(body));
+};
+const compareRequest = (input, output) => {
+	const body = `<?xml version="1.0"?>
+<methodCall>
+  <methodName>compare</methodName>
+  <params>
+    <param><value><string>${input}</string></value></param>
+    <param><value><nil/></value></param>
+    <param><value><string>${output}</string></value></param>
+  </params>
+</methodCall>
+`;
+	return HttpClientRequest.post("").pipe(HttpClientRequest.bodyText(body));
+};
+const getReason = Match.type().pipe(Match.when({
+	faultCode: 1,
+	faultString: String.includes("does not exist")
+}, () => "InputFileNotFound"), Match.when({
+	faultCode: 1,
+	faultString: String.includes("Unknown export file type")
+}, () => "BadOutputExtension"), Match.when({
+	faultCode: 1,
+	faultString: String.includes("is not supported")
+}, () => "MethodNotFound"), Match.when({
+	faultCode: 1,
+	faultString: String.includes("PermissionError")
+}, () => "PermissionDenied"), Match.when({
+	faultCode: 1,
+	faultString: String.includes("Permission denied")
+}, () => "PermissionDenied"), Match.orElse(() => "Unknown"));
+const handleResponse = (response) => response.text.pipe(Effect.map(parseXML), Effect.flatMap(decodeUnoResponse), Effect.flatMap((decoded) => {
+	if ("faultString" in decoded) return new UnoError({
+		reason: getReason(decoded),
+		message: decoded.faultString,
+		cause: decoded
+	});
+	return Effect.succeed(response);
+}));
+var UnoClient = class extends Effect.Service()("libre-convert-effect/uno/UnoClient", { scoped: Effect.gen(function* () {
+	const { url } = yield* UnoServer;
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequestInput(flow(HttpClientRequest.prependUrl(url))), HttpClient.filterStatusOk);
+	return {
+		client,
+		convert(input, output) {
+			return client.execute(convertRequest(input, output)).pipe(Effect.flatMap(handleResponse));
+		},
+		compare(input, output) {
+			return client.execute(compareRequest(input, output)).pipe(Effect.flatMap(handleResponse));
+		}
+	};
+}) }) {};
+
+//#endregion
+//#region src/index.ts
+const runString = (stream) => stream.pipe(Stream.decodeText(), Stream.runFold(String.empty, String.concat));
+var LibreOfficeCmd = class extends Context.Reference()("libre-convert-effect/index/LibreOfficeCmd", { defaultValue: () => ["soffice", "--headless"] }) {};
+var LibreOffice = class LibreOffice extends Effect.Service()("libre-convert-effect/index/LibreOffice", { scoped: Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const sem = yield* Effect.makeSemaphore(1);
+	return { convertLocalFile: Effect.fn(function* (input, output) {
+		const [cmd, ...args] = yield* LibreOfficeCmd;
+		const parsedInput = path.parse(input);
+		const parsedOutput = path.parse(output);
+		if (yield* fs.stat(output).pipe(Effect.map((stat) => stat.type === "Directory"), Effect.catchAll(() => Effect.succeed(false)))) return yield* Effect.fail(new LibreOfficeError({
+			reason: "BadOutputExtension",
+			message: "Output path is a directory"
+		}));
+		const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "effect-libreoffice-" });
+		yield* sem.withPermits(1)(Effect.gen(function* () {
+			const process = yield* Command.make(cmd, ...args, "--convert-to", parsedOutput.ext.slice(1), "--outdir", tempDir, input).pipe(Command.start);
+			const [exitCode, result] = yield* Effect.all([process.exitCode, runString(process.stderr)], { concurrency: "unbounded" });
+			yield* Match.value(String.trim(result)).pipe(Match.when(String.includes("Error: source file could not be loaded"), () => new LibreOfficeError({
+				reason: "InputFileNotFound",
+				message: result
+			})), Match.when(String.includes("Error: no export filter"), () => new LibreOfficeError({
+				reason: "BadOutputExtension",
+				message: result
+			})), Match.when(String.includes("Permission denied"), () => new LibreOfficeError({
+				reason: "PermissionDenied",
+				message: result
+			})), Match.when(String.includes("Error: "), () => new LibreOfficeError({
+				reason: "Unknown",
+				message: result
+			})), Match.orElse(() => Effect.void));
+			if (exitCode !== 0) return yield* new LibreOfficeError({
+				reason: "Unknown",
+				message: result || `Process failed with exit code ${exitCode}`
+			});
+			const libreOutputPath = path.join(tempDir, String.concat(parsedInput.name, parsedOutput.ext));
+			yield* fs.copyFile(libreOutputPath, output);
+		}));
+	}, Effect.scoped) };
+}) }) {
+	/**
+	* The Uno layer uses a unoserver to convert files. It is much more
+	* performant than the cli but requires a unoserver to be running.
+	*/
+	static Uno = Layer.scoped(LibreOffice, Effect.gen(function* () {
+		const client = yield* UnoClient;
+		return LibreOffice.make({ convertLocalFile: flow(client.convert, Effect.as(void 0), Effect.mapError((err) => err instanceof UnoError ? new LibreOfficeError(err) : new LibreOfficeError({
+			reason: "Unknown",
+			message: `Failed to convert file: ${err}`,
+			cause: err
+		}))) });
+	}));
+};
+
+//#endregion
+export { LibreOffice, LibreOfficeCmd };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "effect-libreoffice",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "description": "A effect based LibreOffice converter library",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -19,6 +19,9 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
+  "files": [
+    "dist"
+  ],
   "keywords": [],
   "dependencies": {
     "fast-xml-parser": "^5.3.3"

package/.github/workflows/ci.yml

@@ -1,40 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Install LibreOffice
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends libreoffice-writer
-
-      - name: Lint
-        run: pnpm biome ci .
-
-      - name: Type check
-        run: pnpm type-check
-
-      - name: Test
-        run: pnpm test

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "typescript.tsdk": "node_modules/typescript/lib"
-}

package/Dockerfile

@@ -1,12 +0,0 @@
-FROM alpine:latest
-
-# install fonts https://wiki.alpinelinux.org/wiki/Fonts
-RUN apk add --no-cache font-terminus font-inconsolata font-dejavu font-noto font-noto-cjk font-awesome font-noto-extra
-
-# install libreoffice + dependencies
-RUN apk add --no-cache libreoffice-writer python3 py3-pip openjdk11-jre-headless
-
-# install unoserver via pip
-RUN pip install unoserver --break-system-packages
-
-CMD ["unoserver", "--interface", "0.0.0.0"]

package/biome.json

@@ -1,43 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.3.10/schema.json",
-  "vcs": {
-    "enabled": true,
-    "clientKind": "git",
-    "useIgnoreFile": true
-  },
-  "files": {
-    "ignoreUnknown": true
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space"
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "suspicious": {
-        "noShadowRestrictedNames": "off"
-      },
-      "correctness": {
-        "noUnusedVariables": {
-          "level": "warn",
-          "fix": "none"
-        }
-      }
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "double"
-    }
-  },
-  "assist": {
-    "enabled": true,
-    "actions": {
-      "source": {
-        "organizeImports": "on"
-      }
-    }
-  }
-}

package/compose.yml

@@ -1,19 +0,0 @@
-services:
-  # unoserver:
-  #   image: libreofficedocker/libreoffice-unoserver:3.22
-  #   ports:
-  #     - "2004:2004" # uno rest api
-  #     - "2003:2003" # uno api
-  unoserver:
-    build: .
-    ports:
-      - "2003:2003" # uno api
-    volumes:
-      - /tmp/test-convert:/tmp/test-convert
-    user: "1000:1000"
-    environment:
-      - HOME=/tmp
-    develop:
-      watch:
-        - action: rebuild
-          path: ./Dockerfile

package/docker/ubuntu.Dockerfile

@@ -1,3 +0,0 @@
-FROM ubuntu:24.04
-
-RUN apt-get update && apt-get install -y libreoffice-writer --no-install-recommends

package/examples/cloud-run/compose.yml

@@ -1,5 +0,0 @@
-services:
-  unoserver:
-    build: ./uno.Dockerfile
-  api: 
-    build: ./api.Dockerfile

package/examples/cloud-run/uno.Dockerfile

@@ -1,9 +0,0 @@
-FROM alpine:latest
-
-# install libreoffice + dependencies
-RUN apk add --no-cache libreoffice-writer python3 py3-pip openjdk11-jre-headless
-
-# install unoserver via pip
-RUN pip install unoserver --break-system-packages
-
-CMD ["unoserver"]

package/fixtures/test.txt

@@ -1,7 +0,0 @@
-Hi there
-
-This is a test file.
-
-This should be converted to PDF.
-
-Have fun!