Compare commits
No commits in common. "zig" and "main" have entirely different histories.
21 changed files with 448 additions and 1272 deletions
1
.gitattributes
vendored
1
.gitattributes
vendored
|
|
@ -1 +0,0 @@
|
|||
* text=auto eol=lf
|
||||
19
.gitignore
vendored
19
.gitignore
vendored
|
|
@ -1,19 +0,0 @@
|
|||
# This file is for zig-specific build artifacts.
|
||||
# If you have OS-specific or editor-specific files to ignore,
|
||||
# such as *.swp or .DS_Store, put those in your global
|
||||
# ~/.gitignore and put this in your ~/.gitconfig:
|
||||
#
|
||||
# [core]
|
||||
# excludesfile = ~/.gitignore
|
||||
#
|
||||
# Cheers!
|
||||
# -andrewrk
|
||||
|
||||
.zig-cache/
|
||||
zig-cache/
|
||||
zig-out/
|
||||
/release/
|
||||
/debug/
|
||||
/build/
|
||||
/build-*/
|
||||
/docgen_tmp/
|
||||
13
README.md
13
README.md
|
|
@ -2,5 +2,14 @@
|
|||
|
||||
Jeeves' personal streaming toolkit.
|
||||
|
||||
{insert stereotypical message of This Is A Mess Not Designed For Others}
|
||||
so Good Luck Have Fun :)
|
||||
{insert stereotypical message of This Is A Mess Not Designed For Others} so Good Luck Have Fun :)
|
||||
|
||||
# Usage
|
||||
|
||||
0. (Nix only) Run `nix develop`
|
||||
1. Run VLC with `vlc --extraintf http --http-host localhost --http-password 1234`
|
||||
2. Run OBS Studio
|
||||
3. Create a browser source with a height of 19, width that is a multiple of 8, and point it to `http://localhost:8012/statusline`
|
||||
4. Run Streamboy with `deno run dev`
|
||||
|
||||
Topic is hardcoded for now, but the song info will automatically update with VLC.
|
||||
|
|
|
|||
36
build.zig
36
build.zig
|
|
@ -1,36 +0,0 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub fn build(b: *std.Build) void {
|
||||
const target = b.standardTargetOptions(.{});
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
const exe_mod = b.createModule(.{
|
||||
.root_source_file = b.path("src/main.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
const exe = b.addExecutable(.{
|
||||
.name = "streamboy",
|
||||
.root_module = exe_mod,
|
||||
});
|
||||
b.installArtifact(exe);
|
||||
|
||||
const run_cmd = b.addRunArtifact(exe);
|
||||
run_cmd.step.dependOn(b.getInstallStep());
|
||||
if (b.args) |args| {
|
||||
run_cmd.addArgs(args);
|
||||
}
|
||||
|
||||
const run_step = b.step("run", "Run the app");
|
||||
run_step.dependOn(&run_cmd.step);
|
||||
|
||||
const exe_unit_tests = b.addTest(.{
|
||||
.root_module = exe_mod,
|
||||
});
|
||||
|
||||
const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
|
||||
|
||||
const test_step = b.step("test", "Run unit tests");
|
||||
test_step.dependOn(&run_exe_unit_tests.step);
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
.{
|
||||
.name = "streamboy",
|
||||
.version = "0.0.0",
|
||||
.minimum_zig_version = "0.14.0",
|
||||
.dependencies = .{},
|
||||
.paths = .{
|
||||
"build.zig",
|
||||
"build.zig.zon",
|
||||
"src",
|
||||
"public",
|
||||
},
|
||||
}
|
||||
9
deno.json
Normal file
9
deno.json
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
{
|
||||
"tasks": {
|
||||
"dev": "deno run --allow-net --allow-read --watch src/main.ts"
|
||||
},
|
||||
"imports": {
|
||||
"@oak/oak": "jsr:@oak/oak@^17.1.4",
|
||||
"@std/assert": "jsr:@std/assert@1"
|
||||
}
|
||||
}
|
||||
97
deno.lock
generated
Normal file
97
deno.lock
generated
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
{
|
||||
"version": "4",
|
||||
"specifiers": {
|
||||
"jsr:@oak/commons@1": "1.0.0",
|
||||
"jsr:@oak/oak@^17.1.4": "17.1.4",
|
||||
"jsr:@std/assert@1": "1.0.11",
|
||||
"jsr:@std/bytes@1": "1.0.5",
|
||||
"jsr:@std/crypto@1": "1.0.4",
|
||||
"jsr:@std/encoding@1": "1.0.7",
|
||||
"jsr:@std/encoding@^1.0.7": "1.0.7",
|
||||
"jsr:@std/fmt@0.223": "0.223.0",
|
||||
"jsr:@std/http@1": "1.0.13",
|
||||
"jsr:@std/internal@^1.0.5": "1.0.5",
|
||||
"jsr:@std/media-types@1": "1.1.0",
|
||||
"jsr:@std/path@1": "1.0.8",
|
||||
"npm:fast-xml-parser@*": "4.5.2",
|
||||
"npm:path-to-regexp@^6.3.0": "6.3.0"
|
||||
},
|
||||
"jsr": {
|
||||
"@oak/commons@1.0.0": {
|
||||
"integrity": "49805b55603c3627a9d6235c0655aa2b6222d3036b3a13ff0380c16368f607ac",
|
||||
"dependencies": [
|
||||
"jsr:@std/assert",
|
||||
"jsr:@std/bytes",
|
||||
"jsr:@std/crypto",
|
||||
"jsr:@std/encoding@1",
|
||||
"jsr:@std/http",
|
||||
"jsr:@std/media-types"
|
||||
]
|
||||
},
|
||||
"@oak/oak@17.1.4": {
|
||||
"integrity": "60530b582bf276ff741e39cc664026781aa08dd5f2bc5134d756cc427bf2c13e",
|
||||
"dependencies": [
|
||||
"jsr:@oak/commons",
|
||||
"jsr:@std/assert",
|
||||
"jsr:@std/bytes",
|
||||
"jsr:@std/http",
|
||||
"jsr:@std/media-types",
|
||||
"jsr:@std/path",
|
||||
"npm:path-to-regexp"
|
||||
]
|
||||
},
|
||||
"@std/assert@1.0.11": {
|
||||
"integrity": "2461ef3c368fe88bc60e186e7744a93112f16fd110022e113a0849e94d1c83c1",
|
||||
"dependencies": [
|
||||
"jsr:@std/internal"
|
||||
]
|
||||
},
|
||||
"@std/bytes@1.0.5": {
|
||||
"integrity": "4465dd739d7963d964c809202ebea6d5c6b8e3829ef25c6a224290fbb8a1021e"
|
||||
},
|
||||
"@std/crypto@1.0.4": {
|
||||
"integrity": "cee245c453bd5366207f4d8aa25ea3e9c86cecad2be3fefcaa6cb17203d79340"
|
||||
},
|
||||
"@std/encoding@1.0.7": {
|
||||
"integrity": "f631247c1698fef289f2de9e2a33d571e46133b38d042905e3eac3715030a82d"
|
||||
},
|
||||
"@std/fmt@0.223.0": {
|
||||
"integrity": "6deb37794127dfc7d7bded2586b9fc6f5d50e62a8134846608baf71ffc1a5208"
|
||||
},
|
||||
"@std/http@1.0.13": {
|
||||
"integrity": "d29618b982f7ae44380111f7e5b43da59b15db64101198bb5f77100d44eb1e1e",
|
||||
"dependencies": [
|
||||
"jsr:@std/encoding@^1.0.7"
|
||||
]
|
||||
},
|
||||
"@std/internal@1.0.5": {
|
||||
"integrity": "54a546004f769c1ac9e025abd15a76b6671ddc9687e2313b67376125650dc7ba"
|
||||
},
|
||||
"@std/media-types@1.1.0": {
|
||||
"integrity": "c9d093f0c05c3512932b330e3cc1fe1d627b301db33a4c2c2185c02471d6eaa4"
|
||||
},
|
||||
"@std/path@1.0.8": {
|
||||
"integrity": "548fa456bb6a04d3c1a1e7477986b6cffbce95102d0bb447c67c4ee70e0364be"
|
||||
}
|
||||
},
|
||||
"npm": {
|
||||
"fast-xml-parser@4.5.2": {
|
||||
"integrity": "sha512-xmnYV9o0StIz/0ArdzmWTxn9oDy0lH8Z80/8X/TD2EUQKXY4DHxoT9mYBqgGIG17DgddCJtH1M6DriMbalNsAA==",
|
||||
"dependencies": [
|
||||
"strnum"
|
||||
]
|
||||
},
|
||||
"path-to-regexp@6.3.0": {
|
||||
"integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="
|
||||
},
|
||||
"strnum@1.0.5": {
|
||||
"integrity": "sha512-J8bbNyKKXl5qYcR36TIO8W3mVGVHrmmxsd5PAItGkmyzwJvybiw2IVq5nqd0i4LSNSkB/sx9VHllbfFdr9k1JA=="
|
||||
}
|
||||
},
|
||||
"workspace": {
|
||||
"dependencies": [
|
||||
"jsr:@oak/oak@^17.1.4",
|
||||
"jsr:@std/assert@1"
|
||||
]
|
||||
}
|
||||
}
|
||||
29
flake.lock
generated
29
flake.lock
generated
|
|
@ -20,22 +20,24 @@
|
|||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1736817698,
|
||||
"narHash": "sha256-1m+JP9RUsbeLVv/tF1DX3Ew9Vl/fatXnlh/g5k3jcSk=",
|
||||
"lastModified": 1739736696,
|
||||
"narHash": "sha256-zON2GNBkzsIyALlOCFiEBcIjI4w38GYOb+P+R4S8Jsw=",
|
||||
"owner": "nixos",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "2b1fca3296ddd1602d2c4f104a4050e006f4b0cb",
|
||||
"rev": "d74a2335ac9c133d6bbec9fc98d91a77f1604c1f",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nixos",
|
||||
"ref": "nixos-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"zig2nix": "zig2nix"
|
||||
"flake-utils": "flake-utils",
|
||||
"nixpkgs": "nixpkgs"
|
||||
}
|
||||
},
|
||||
"systems": {
|
||||
|
|
@ -52,25 +54,6 @@
|
|||
"repo": "default",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"zig2nix": {
|
||||
"inputs": {
|
||||
"flake-utils": "flake-utils",
|
||||
"nixpkgs": "nixpkgs"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1739670160,
|
||||
"narHash": "sha256-9QI3sDNp+Pmr7mcaeabqXrADaF8SAZ98LnB/I23FnXs=",
|
||||
"owner": "Cloudef",
|
||||
"repo": "zig2nix",
|
||||
"rev": "3dae27fb3c702b7f28425518e914b0ab34575ff5",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "Cloudef",
|
||||
"repo": "zig2nix",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
|
|
|
|||
46
flake.nix
46
flake.nix
|
|
@ -1,41 +1,15 @@
|
|||
{
|
||||
inputs = {
|
||||
zig2nix.url = "github:Cloudef/zig2nix";
|
||||
nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
|
||||
flake-utils.url = "github:numtide/flake-utils";
|
||||
};
|
||||
|
||||
outputs = { zig2nix, ... }: let
|
||||
flake-utils = zig2nix.inputs.flake-utils;
|
||||
in (flake-utils.lib.eachDefaultSystem (system: let
|
||||
env = zig2nix.outputs.zig-env.${system} { zig = zig2nix.outputs.packages.${system}.zig.master.bin; };
|
||||
system-triple = env.lib.zigTripleFromString system;
|
||||
in with builtins; with env.lib; with env.pkgs.lib; rec {
|
||||
packages.target = genAttrs allTargetTriples (target: env.packageForTarget target ({
|
||||
src = cleanSource ./.;
|
||||
|
||||
nativeBuildInputs = with env.pkgs; [];
|
||||
buildInputs = with env.pkgsForTarget target; [];
|
||||
|
||||
zigPreferMusl = true;
|
||||
zigDisableWrap = true;
|
||||
}));
|
||||
|
||||
packages.default = packages.target.${system-triple}.override {
|
||||
zigPreferMusl = false;
|
||||
zigDisableWrap = false;
|
||||
};
|
||||
|
||||
apps.bundle.default = apps.bundle.target.${system-triple};
|
||||
|
||||
apps.default = env.app [] "zig build run -- \"$@\"";
|
||||
apps.build = env.app [] "zig build \"$@\"";
|
||||
apps.test = env.app [] "zig build test -- \"$@\"";
|
||||
apps.docs = env.app [] "zig build docs -- \"$@\"";
|
||||
apps.deps = env.showExternalDeps;
|
||||
|
||||
apps.zon2json = env.app [env.zon2json] "zon2json \"$@\"";
|
||||
apps.zon2json-lock = env.app [env.zon2json-lock] "zon2json-lock \"$@\"";
|
||||
apps.zon2nix = env.app [env.zon2nix] "zon2nix \"$@\"";
|
||||
|
||||
devShells.default = env.mkShell {};
|
||||
}));
|
||||
outputs = { self, nixpkgs, flake-utils }:
|
||||
flake-utils.lib.eachDefaultSystem(system: let
|
||||
pkgs = nixpkgs.legacyPackages.${system};
|
||||
in {
|
||||
# packages.default = pkgs.callPackage ./default.nix {};
|
||||
devShells.default = import ./shell.nix { inherit pkgs; };
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
5
shell.nix
Normal file
5
shell.nix
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
{ pkgs ? import <nixpkgs> {} }:
|
||||
pkgs.mkShell {
|
||||
packages = with pkgs; [deno];
|
||||
}
|
||||
|
||||
126
src/main.ts
Normal file
126
src/main.ts
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
import { Application, Router } from "@oak/oak";
|
||||
import { XMLParser } from "npm:fast-xml-parser";
|
||||
|
||||
const router = new Router();
|
||||
|
||||
let wsClients: WebSocket[] = [];
|
||||
|
||||
router.get("/", (context) => {
|
||||
if (context.isUpgradable) {
|
||||
const ws = context.upgrade();
|
||||
ws.onopen = () => wsClients.push(ws);
|
||||
ws.onclose = () => wsClients = wsClients.filter((client) => client != ws);
|
||||
}
|
||||
});
|
||||
|
||||
router
|
||||
.get("/statusline", async (ctx) => {
|
||||
ctx.response.body = await Deno.readFile("web/statusline.html");
|
||||
})
|
||||
.get("/statusline.js", async (ctx) => {
|
||||
ctx.response.body = await Deno.readFile("web/statusline.js");
|
||||
})
|
||||
.get("/gone", async (ctx) => {
|
||||
ctx.response.body = await Deno.readFile("web/gone.html");
|
||||
})
|
||||
.get("/gone.js", async (ctx) => {
|
||||
ctx.response.body = await Deno.readFile("web/gone.js");
|
||||
})
|
||||
.get("/style.css", async (ctx) => {
|
||||
ctx.response.body = await Deno.readFile("web/style.css");
|
||||
});
|
||||
|
||||
const app = new Application();
|
||||
app.use(router.routes());
|
||||
app.use(router.allowedMethods());
|
||||
|
||||
app.addEventListener("listen", ({ hostname, port }) => {
|
||||
console.log(`Start listening on ${hostname}:${port}`);
|
||||
});
|
||||
|
||||
app.listen({ port: 8012 });
|
||||
|
||||
const topic =
|
||||
"Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy";
|
||||
|
||||
setInterval(async () => {
|
||||
let songinfo: SongInfo | null = null;
|
||||
try {
|
||||
songinfo = await getVlcSongInfo();
|
||||
} catch (e) {
|
||||
console.log(`getVlcSongInfo() error: ${e}`);
|
||||
// properly handling this error is by ignoring it,
|
||||
// since then that leaves songinfo as null,
|
||||
// and that is guaranteed to be handled correctly.
|
||||
}
|
||||
|
||||
const data = {
|
||||
blocks: [{ text: topic, color: "#ffffff" }],
|
||||
};
|
||||
if (songinfo != null) {
|
||||
data.blocks.push({
|
||||
text: `♪ ${songinfo.title} - ${songinfo.artist}`,
|
||||
color: "#ffffff",
|
||||
});
|
||||
}
|
||||
for (const ws of wsClients) {
|
||||
ws.send(JSON.stringify(data));
|
||||
}
|
||||
}, 900);
|
||||
|
||||
interface SongInfo {
|
||||
title?: string;
|
||||
artist?: string;
|
||||
album?: string;
|
||||
}
|
||||
|
||||
async function getVlcSongInfo(): Promise<SongInfo> {
|
||||
const parser = new XMLParser({ ignoreAttributes: false });
|
||||
const password = "1234";
|
||||
|
||||
const res = await fetch("http://localhost:8080/requests/status.xml", {
|
||||
headers: { authorization: `Basic ${btoa(`:${password}`)}` },
|
||||
});
|
||||
|
||||
const json = parser.parse(await res.text());
|
||||
|
||||
const songinfo: SongInfo = {};
|
||||
|
||||
try {
|
||||
for (const category of json.root.information.category) {
|
||||
if (category["@_name"] != "meta") continue;
|
||||
for (const property of category.info) {
|
||||
if (property["@_name"] == "title") {
|
||||
songinfo.title = processBadXmlString(property["#text"]);
|
||||
} else if (property["@_name"] == "artist") {
|
||||
songinfo.artist = processBadXmlString(property["#text"]);
|
||||
} else if (property["@_name"] == "album") {
|
||||
songinfo.album = processBadXmlString(property["#text"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
songinfo.title = "Unknown Title";
|
||||
songinfo.artist = "Unknown Artist";
|
||||
songinfo.album = "Unknown Album";
|
||||
}
|
||||
|
||||
return songinfo;
|
||||
}
|
||||
|
||||
function processBadXmlString(str: string): string {
|
||||
let newStr = str;
|
||||
|
||||
while (true) {
|
||||
const amp = newStr.indexOf("&#");
|
||||
if (amp > 0) {
|
||||
const semi = newStr.indexOf(";", amp);
|
||||
if (semi > 0) {
|
||||
const int = String.fromCharCode(parseInt(newStr.slice(amp + 2, semi)));
|
||||
newStr = newStr.replace(newStr.slice(amp, semi + 1), int);
|
||||
} else break;
|
||||
} else break;
|
||||
}
|
||||
|
||||
return newStr;
|
||||
}
|
||||
398
src/main.zig
398
src/main.zig
|
|
@ -1,398 +0,0 @@
|
|||
const std = @import("std");
|
||||
|
||||
// Music Player:
|
||||
// - Launch VLC and control it via HTTP interface
|
||||
// - Play music randomly from a VLC playlist
|
||||
// - Allow media control (play pause, next, prev)
|
||||
// - Expose OBS Browser Source to display current track information.
|
||||
// + Add and remove songs from playlist
|
||||
// + Allow voting on songs (web interface? chat bot?)
|
||||
//
|
||||
// Chat bot:
|
||||
// - Support Twitch chat
|
||||
// + Support YouTube
|
||||
//
|
||||
// A - means immediately, a + means eventually.
|
||||
|
||||
pub fn main() !void {
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer _ = gpa.deinit();
|
||||
const allocator = gpa.allocator();
|
||||
|
||||
var vlc = try VLC.init(allocator, try std.Uri.parse("http://localhost:8080"));
|
||||
defer vlc.deinit();
|
||||
|
||||
// var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
|
||||
// defer tz_file.close();
|
||||
// var tz = try std.tz.Tz.parse(allocator, tz_file.reader());
|
||||
// defer tz.deinit();
|
||||
|
||||
var server = try std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 8009).listen(.{});
|
||||
defer server.deinit();
|
||||
|
||||
var clients = std.ArrayList(Client).init(allocator);
|
||||
defer {
|
||||
for (0..clients.items.len) |i| clients.items[i].deinit(allocator);
|
||||
clients.deinit();
|
||||
}
|
||||
|
||||
// var delay: u8 = 0;
|
||||
while (true) {
|
||||
var pollfds = std.ArrayList(std.posix.pollfd).init(allocator);
|
||||
defer pollfds.deinit();
|
||||
try pollfds.append(.{ .fd = server.stream.handle, .events = std.posix.POLL.IN, .revents = 0 });
|
||||
for (clients.items, 0..) |client, i| {
|
||||
std.debug.print("appending client {d} to poll()\n", .{i});
|
||||
try pollfds.append(.{ .fd = client.connection.stream.handle, .events = std.posix.POLL.IN, .revents = 0 });
|
||||
}
|
||||
const num = try std.posix.poll(pollfds.items, 100);
|
||||
// std.debug.print("num pollfds {d}\n", .{num});
|
||||
_ = num;
|
||||
if (pollfds.items[0].revents != 0) {
|
||||
const read_buf = try allocator.alloc(u8, 1024 * 32);
|
||||
defer allocator.free(read_buf);
|
||||
|
||||
const connection = try server.accept();
|
||||
errdefer connection.stream.close();
|
||||
|
||||
var http = std.http.Server.init(connection, read_buf);
|
||||
var request = try http.receiveHead();
|
||||
std.debug.print("Target: {s}\n", .{request.head.target});
|
||||
|
||||
var websocket: std.http.WebSocket = undefined;
|
||||
|
||||
const send_buf = try allocator.alloc(u8, 1024 * 32);
|
||||
errdefer allocator.free(send_buf);
|
||||
const recv_buf = try allocator.alignedAlloc(u8, 4, 1024 * 32);
|
||||
errdefer allocator.free(recv_buf);
|
||||
|
||||
const is_websocket = try websocket.init(&request, send_buf, recv_buf);
|
||||
if (is_websocket) {
|
||||
// if websocket, we clean up at the end of main(), not the end of the block
|
||||
try websocket.response.flush();
|
||||
std.debug.print("is a websocket now\n", .{});
|
||||
|
||||
const client = Client{
|
||||
.connection = connection,
|
||||
.websocket = websocket,
|
||||
.send_buf = send_buf,
|
||||
.recv_buf = recv_buf,
|
||||
};
|
||||
try clients.append(client);
|
||||
} else {
|
||||
// if normal HTTP, clean up at the end of the block
|
||||
defer connection.stream.close();
|
||||
switch (request.head.method) {
|
||||
.GET, .HEAD => {
|
||||
if (std.mem.eql(u8, request.head.target, "/gone")) {
|
||||
try request.respond(@embedFile("web/gone.html"), .{});
|
||||
} else if (std.mem.eql(u8, request.head.target, "/statusline")) {
|
||||
try request.respond(@embedFile("web/statusline.html"), .{});
|
||||
} else if (std.mem.eql(u8, request.head.target, "/gone.js")) {
|
||||
try request.respond(@embedFile("web/gone.js"), .{});
|
||||
} else if (std.mem.eql(u8, request.head.target, "/statusline.js")) {
|
||||
try request.respond(@embedFile("web/statusline.js"), .{});
|
||||
} else if (std.mem.eql(u8, request.head.target, "/style.css")) {
|
||||
try request.respond(@embedFile("web/style.css"), .{});
|
||||
} else {
|
||||
try request.respond("", .{ .status = .not_found });
|
||||
}
|
||||
},
|
||||
else => try request.respond("", .{ .status = .not_found }),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const status_string = try getStatusString(allocator, &vlc);
|
||||
defer allocator.free(status_string);
|
||||
for (1..pollfds.items.len) |i| {
|
||||
const pollfd = pollfds.items[i];
|
||||
var client = &clients.items[i - 1];
|
||||
std.debug.print("client idx {d} for status update\nrevents {d}\n", .{ i - 1, pollfd.revents });
|
||||
// try std.http.WebSocket.writeMessage(&client.websocket, status_string, .text);
|
||||
if (pollfd.revents & std.posix.POLL.IN != 0) {
|
||||
const data = std.http.WebSocket.readSmallMessage(&client.websocket) catch |e| switch (e) {
|
||||
error.EndOfStream => continue,
|
||||
error.ConnectionClose => continue,
|
||||
else => return e,
|
||||
};
|
||||
std.debug.print("recieved opcode: {any} with data {s}\n", .{ data.opcode, data.data });
|
||||
}
|
||||
}
|
||||
|
||||
std.Thread.sleep(1_000_000_000);
|
||||
}
|
||||
}
|
||||
|
||||
const Client = struct {
|
||||
connection: std.net.Server.Connection,
|
||||
websocket: std.http.WebSocket,
|
||||
send_buf: []u8,
|
||||
recv_buf: []align(4) u8,
|
||||
|
||||
pub fn deinit(self: *Client, allocator: std.mem.Allocator) void {
|
||||
allocator.free(self.send_buf);
|
||||
allocator.free(self.recv_buf);
|
||||
self.connection.stream.close();
|
||||
}
|
||||
};
|
||||
|
||||
const base64_encoder = std.base64.standard.Encoder;
|
||||
|
||||
// TODO make the URL something short like jeevio.xyz/streamboy
|
||||
const topic = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy";
|
||||
|
||||
fn getStatusString(allocator: std.mem.Allocator, vlc: *VLC) ![]u8 {
|
||||
var song_info = try vlc.getSongInfo();
|
||||
defer song_info.deinit();
|
||||
|
||||
const string = try std.fmt.allocPrint(allocator, "{s} | ♪ {s} - {s} | ", .{
|
||||
topic,
|
||||
song_info.title orelse "Unknown Title",
|
||||
song_info.artist orelse "Unknown Artist",
|
||||
});
|
||||
errdefer allocator.free(string);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
pub const VLC = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
http: std.http.Client,
|
||||
base_uri: std.Uri,
|
||||
authorization: []u8,
|
||||
|
||||
pub fn init(allocator: std.mem.Allocator, base_uri: std.Uri) !VLC {
|
||||
const userpass = try std.fmt.allocPrint(allocator, ":{s}", .{"1234"});
|
||||
defer allocator.free(userpass);
|
||||
|
||||
const base64_userpass = try allocator.alloc(u8, base64_encoder.calcSize(userpass.len));
|
||||
defer allocator.free(base64_userpass);
|
||||
|
||||
const authorization = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
|
||||
errdefer allocator.free(authorization);
|
||||
|
||||
// TODO actually launch VLC
|
||||
// var vlc = std.process.Child.init(&[_][]const u8{
|
||||
// "vlc",
|
||||
// "--intf",
|
||||
// "http",
|
||||
// "--http-host",
|
||||
// "localhost",
|
||||
// "--http-password",
|
||||
// "1234",
|
||||
// }, allocator);
|
||||
// try vlc.spawn();
|
||||
|
||||
return .{
|
||||
.allocator = allocator,
|
||||
.http = std.http.Client{ .allocator = allocator },
|
||||
.base_uri = base_uri,
|
||||
.authorization = authorization,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *VLC) void {
|
||||
self.http.deinit();
|
||||
self.allocator.free(self.authorization);
|
||||
// try vlc.kill();
|
||||
}
|
||||
|
||||
fn request(self: *VLC, uri: std.Uri) !Response {
|
||||
var combined_uri = self.base_uri;
|
||||
combined_uri.path = uri.path;
|
||||
combined_uri.query = uri.query;
|
||||
combined_uri.fragment = uri.fragment;
|
||||
|
||||
var response = std.ArrayList(u8).init(self.allocator);
|
||||
defer response.deinit();
|
||||
|
||||
const result = try self.http.fetch(.{
|
||||
.location = .{ .uri = combined_uri },
|
||||
.headers = .{ .authorization = .{ .override = self.authorization } },
|
||||
.response_storage = .{ .dynamic = &response },
|
||||
});
|
||||
|
||||
// std.debug.print("{any}\n{s}\n", .{ result, response.items });
|
||||
|
||||
if (result.status != .ok) return error.HttpRequestFailed;
|
||||
|
||||
const buffer = try response.toOwnedSlice();
|
||||
return .{
|
||||
.buffer = buffer,
|
||||
.document = try xml.parse(self.allocator, buffer),
|
||||
};
|
||||
}
|
||||
|
||||
const Response = struct {
|
||||
buffer: []u8,
|
||||
document: xml.Document,
|
||||
|
||||
pub fn deinit(self: *Response, allocator: std.mem.Allocator) void {
|
||||
self.document.deinit();
|
||||
allocator.free(self.buffer);
|
||||
}
|
||||
};
|
||||
|
||||
pub const SongInfo = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
title: ?[]const u8,
|
||||
album: ?[]const u8,
|
||||
artist: ?[]const u8,
|
||||
|
||||
pub fn deinit(self: *SongInfo) void {
|
||||
if (self.title) |b| self.allocator.free(b);
|
||||
if (self.album) |b| self.allocator.free(b);
|
||||
if (self.artist) |b| self.allocator.free(b);
|
||||
}
|
||||
};
|
||||
|
||||
pub fn getSongInfo(self: *VLC) !SongInfo {
|
||||
var response = try self.request(.{ .scheme = "http", .path = .{ .percent_encoded = "/requests/status.xml" } });
|
||||
defer response.deinit(self.allocator);
|
||||
|
||||
// std.debug.print("{s}\n", .{response.buffer});
|
||||
|
||||
var title: ?[]const u8 = null;
|
||||
var album: ?[]const u8 = null;
|
||||
var artist: ?[]const u8 = null;
|
||||
|
||||
if (response.document.root.findChildByTag("information")) |information| {
|
||||
var categories_it = information.findChildrenByTag("category");
|
||||
while (categories_it.next()) |category| {
|
||||
if (std.mem.eql(u8, category.getAttribute("name").?, "meta")) {
|
||||
var info_it = category.findChildrenByTag("info");
|
||||
while (info_it.next()) |info| {
|
||||
const info_name = info.getAttribute("name").?;
|
||||
if (std.mem.eql(u8, info_name, "title"))
|
||||
title = try processHtmlString(self, info.children[0].char_data)
|
||||
else if (std.mem.eql(u8, info_name, "album"))
|
||||
album = try processHtmlString(self, info.children[0].char_data)
|
||||
else if (std.mem.eql(u8, info_name, "artist"))
|
||||
artist = try processHtmlString(self, info.children[0].char_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return .{
|
||||
.allocator = self.allocator,
|
||||
.title = title,
|
||||
.album = album,
|
||||
.artist = artist,
|
||||
};
|
||||
}
|
||||
|
||||
// TODO clean up
|
||||
fn processHtmlString(self: *VLC, string: []const u8) ![]const u8 {
|
||||
var new: []u8 = try self.allocator.dupe(u8, string);
|
||||
errdefer self.allocator.free(new);
|
||||
while (true) {
|
||||
if (std.mem.indexOf(u8, new, "&#")) |amp| {
|
||||
if (std.mem.indexOfScalarPos(u8, new, amp, ';')) |semi| {
|
||||
const int = try std.fmt.parseInt(u8, new[amp + 2 .. semi], 10);
|
||||
const nnew = try self.allocator.alloc(u8, std.mem.replacementSize(u8, new, new[amp .. semi + 1], &[1]u8{int}));
|
||||
_ = std.mem.replace(u8, new, new[amp .. semi + 1], &[1]u8{int}, nnew);
|
||||
self.allocator.free(new);
|
||||
new = nnew;
|
||||
}
|
||||
} else break;
|
||||
}
|
||||
// std.debug.print("{s}\n", .{new});
|
||||
return new;
|
||||
}
|
||||
|
||||
const xml = @import("./xml.zig");
|
||||
};
|
||||
|
||||
fn updateTime(tz: std.Tz) !void {
|
||||
const original_timestamp = std.time.timestamp();
|
||||
|
||||
var timetype: *std.tz.Timetype = undefined;
|
||||
for (tz.transitions, 0..) |trans, i|
|
||||
if (trans.ts >= original_timestamp) {
|
||||
timetype = tz.transitions[i - 1].timetype;
|
||||
break;
|
||||
};
|
||||
|
||||
const timestamp = std.time.timestamp() + timetype.offset + std.time.s_per_day;
|
||||
|
||||
const epoch_seconds = std.time.epoch.EpochSeconds{ .secs = @intCast(timestamp) };
|
||||
const day_seconds = epoch_seconds.getDaySeconds();
|
||||
const epoch_day = epoch_seconds.getEpochDay();
|
||||
const year_day = epoch_day.calculateYearDay();
|
||||
const month_day = year_day.calculateMonthDay();
|
||||
|
||||
const ampm = getAmPm(day_seconds);
|
||||
|
||||
var file = try std.fs.createFileAbsolute("/tmp/time", .{ .truncate = true });
|
||||
defer file.close();
|
||||
|
||||
try file.writer().print("{s}, {s} {d} {d}, {d:0>2}:{d:0>2}:{d:0>2} {s}", .{
|
||||
getDayOfWeekName(getDayOfWeek(epoch_day)),
|
||||
getMonthName(month_day.month),
|
||||
month_day.day_index,
|
||||
year_day.year,
|
||||
ampm.hour,
|
||||
day_seconds.getMinutesIntoHour(),
|
||||
day_seconds.getSecondsIntoMinute(),
|
||||
if (ampm.is_pm) "PM" else "AM",
|
||||
});
|
||||
}
|
||||
|
||||
fn getMonthName(month: std.time.epoch.Month) []const u8 {
|
||||
return switch (month) {
|
||||
.jan => "January",
|
||||
.feb => "February",
|
||||
.mar => "March",
|
||||
.apr => "April",
|
||||
.may => "May",
|
||||
.jun => "June",
|
||||
.jul => "July",
|
||||
.aug => "August",
|
||||
.sep => "September",
|
||||
.oct => "October",
|
||||
.nov => "November",
|
||||
.dec => "December",
|
||||
};
|
||||
}
|
||||
|
||||
// Jan 1 1970 was a Thursday, so we make that 1
|
||||
const DayOfWeek = enum(u3) {
|
||||
wed = 0,
|
||||
thu,
|
||||
fri,
|
||||
sat,
|
||||
sun,
|
||||
mon,
|
||||
tue,
|
||||
};
|
||||
|
||||
fn getDayOfWeek(epoch_day: std.time.epoch.EpochDay) DayOfWeek {
|
||||
return @enumFromInt(@mod(epoch_day.day, 7));
|
||||
}
|
||||
|
||||
fn getDayOfWeekName(day_of_week: DayOfWeek) []const u8 {
|
||||
return switch (day_of_week) {
|
||||
.sun => "Sunday",
|
||||
.mon => "Monday",
|
||||
.tue => "Tuesday",
|
||||
.wed => "Wednesday",
|
||||
.thu => "Thursday",
|
||||
.fri => "Friday",
|
||||
.sat => "Saturday",
|
||||
};
|
||||
}
|
||||
|
||||
const AmPm = struct {
|
||||
hour: u4,
|
||||
is_pm: bool,
|
||||
};
|
||||
|
||||
fn getAmPm(day_seconds: std.time.epoch.DaySeconds) AmPm {
|
||||
const hour = day_seconds.getHoursIntoDay();
|
||||
return .{
|
||||
.hour = if (hour < 13) @intCast(hour) else @intCast(hour - 12),
|
||||
.is_pm = hour != 0 and hour > 11,
|
||||
};
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
// Sunday, February 16 2025, 03:06:20 PM
|
||||
|
||||
const dateElement = document.getElementById("date");
|
||||
|
||||
const months = [
|
||||
"January",
|
||||
"February",
|
||||
"March",
|
||||
"April",
|
||||
"May",
|
||||
"June",
|
||||
"July",
|
||||
"August",
|
||||
"September",
|
||||
"October",
|
||||
"November",
|
||||
"December",
|
||||
];
|
||||
|
||||
const daysOfWeek = [
|
||||
"Sunday",
|
||||
"Monday",
|
||||
"Tuesday",
|
||||
"Wednesday",
|
||||
"Thursday",
|
||||
"Friday",
|
||||
"Saturday",
|
||||
];
|
||||
|
||||
function updateDateTime() {
|
||||
const date = new Date();
|
||||
|
||||
const seconds = date.getSeconds();
|
||||
const minutes = date.getMinutes();
|
||||
const hours24 = date.getHours();
|
||||
const hours12 = hours24 % 12;
|
||||
const ampm = hours24 > 11 && hours24 != 0 ? "PM" : "AM";
|
||||
const secondsString = String(seconds).padStart(2, "0");
|
||||
const minutesString = String(minutes).padStart(2, "0");
|
||||
|
||||
const year = date.getFullYear();
|
||||
const month = months[date.getMonth()];
|
||||
const day = date.getDate();
|
||||
const dayOfWeek = daysOfWeek[date.getDay()];
|
||||
|
||||
dateElement.innerText = `${dayOfWeek}, ${month} ${day} ${year}, ${hours12}:${minutesString}:${secondsString} ${ampm}`;
|
||||
}
|
||||
|
||||
setInterval(updateDateTime, 1000);
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
const statusLineElement = document.getElementById("status-line");
|
||||
|
||||
const socket = new WebSocket("ws://localhost:8009");
|
||||
|
||||
socket.addEventListener("message", (event) => {
|
||||
console.log(event);
|
||||
statusLineElement.textContent = event.data;
|
||||
});
|
||||
|
||||
// const status = {
|
||||
// blocks: [
|
||||
// "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy",
|
||||
// "♪ Bonhomme de Neige (EarthBound) - Ridley Snipes feat. Earth Kid",
|
||||
// ],
|
||||
// };
|
||||
|
||||
// setInterval(() => {
|
||||
// // statusText = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy | ♪ Bonhomme de Neige (EarthBound) - Ridley Snipes feat. Earth Kid | ";
|
||||
// }, 5000);
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
body {
|
||||
font-family: Unifont;
|
||||
background-color: black;
|
||||
color: white;
|
||||
margin: 0px auto;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
#gone {
|
||||
font-size: 64px;
|
||||
}
|
||||
|
||||
#status-line {
|
||||
font-size: 16px;
|
||||
margin: 0px;
|
||||
white-space: nowrap;
|
||||
animation: marquee 5s linear infinite;
|
||||
max-width: none;
|
||||
}
|
||||
|
||||
@keyframes marquee {
|
||||
from {
|
||||
left: -100%;
|
||||
}
|
||||
to {
|
||||
left: 100%;
|
||||
}
|
||||
}
|
||||
646
src/xml.zig
646
src/xml.zig
|
|
@ -1,646 +0,0 @@
|
|||
// Copyright © 2020-2022 Robin Voetter
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
const std = @import("std");
|
||||
const mem = std.mem;
|
||||
const testing = std.testing;
|
||||
const Allocator = mem.Allocator;
|
||||
const ArenaAllocator = std.heap.ArenaAllocator;
|
||||
|
||||
pub const Attribute = struct {
|
||||
name: []const u8,
|
||||
value: []const u8,
|
||||
};
|
||||
|
||||
pub const Content = union(enum) {
|
||||
char_data: []const u8,
|
||||
comment: []const u8,
|
||||
element: *Element,
|
||||
};
|
||||
|
||||
pub const Element = struct {
|
||||
tag: []const u8,
|
||||
attributes: []Attribute = &.{},
|
||||
children: []Content = &.{},
|
||||
|
||||
pub fn getAttribute(self: Element, attrib_name: []const u8) ?[]const u8 {
|
||||
for (self.attributes) |child| {
|
||||
if (mem.eql(u8, child.name, attrib_name)) {
|
||||
return child.value;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
pub fn getCharData(self: Element, child_tag: []const u8) ?[]const u8 {
|
||||
const child = self.findChildByTag(child_tag) orelse return null;
|
||||
if (child.children.len != 1) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return switch (child.children[0]) {
|
||||
.char_data => |char_data| char_data,
|
||||
else => null,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn iterator(self: Element) ChildIterator {
|
||||
return .{
|
||||
.items = self.children,
|
||||
.i = 0,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn elements(self: Element) ChildElementIterator {
|
||||
return .{
|
||||
.inner = self.iterator(),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn findChildByTag(self: Element, tag: []const u8) ?*Element {
|
||||
var it = self.findChildrenByTag(tag);
|
||||
return it.next();
|
||||
}
|
||||
|
||||
pub fn findChildrenByTag(self: Element, tag: []const u8) FindChildrenByTagIterator {
|
||||
return .{
|
||||
.inner = self.elements(),
|
||||
.tag = tag,
|
||||
};
|
||||
}
|
||||
|
||||
pub const ChildIterator = struct {
|
||||
items: []Content,
|
||||
i: usize,
|
||||
|
||||
pub fn next(self: *ChildIterator) ?*Content {
|
||||
if (self.i < self.items.len) {
|
||||
self.i += 1;
|
||||
return &self.items[self.i - 1];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
pub const ChildElementIterator = struct {
|
||||
inner: ChildIterator,
|
||||
|
||||
pub fn next(self: *ChildElementIterator) ?*Element {
|
||||
while (self.inner.next()) |child| {
|
||||
if (child.* != .element) {
|
||||
continue;
|
||||
}
|
||||
|
||||
return child.*.element;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
pub const FindChildrenByTagIterator = struct {
|
||||
inner: ChildElementIterator,
|
||||
tag: []const u8,
|
||||
|
||||
pub fn next(self: *FindChildrenByTagIterator) ?*Element {
|
||||
while (self.inner.next()) |child| {
|
||||
if (!mem.eql(u8, child.tag, self.tag)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
return child;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
pub const Document = struct {
|
||||
arena: ArenaAllocator,
|
||||
xml_decl: ?*Element,
|
||||
root: *Element,
|
||||
|
||||
pub fn deinit(self: Document) void {
|
||||
var arena = self.arena; // Copy to stack so self can be taken by value.
|
||||
arena.deinit();
|
||||
}
|
||||
};
|
||||
|
||||
const Parser = struct {
|
||||
source: []const u8,
|
||||
offset: usize,
|
||||
line: usize,
|
||||
column: usize,
|
||||
|
||||
fn init(source: []const u8) Parser {
|
||||
return .{
|
||||
.source = source,
|
||||
.offset = 0,
|
||||
.line = 0,
|
||||
.column = 0,
|
||||
};
|
||||
}
|
||||
|
||||
fn peek(self: *Parser) ?u8 {
|
||||
return if (self.offset < self.source.len) self.source[self.offset] else null;
|
||||
}
|
||||
|
||||
fn consume(self: *Parser) !u8 {
|
||||
if (self.offset < self.source.len) {
|
||||
return self.consumeNoEof();
|
||||
}
|
||||
|
||||
return error.UnexpectedEof;
|
||||
}
|
||||
|
||||
fn consumeNoEof(self: *Parser) u8 {
|
||||
std.debug.assert(self.offset < self.source.len);
|
||||
const c = self.source[self.offset];
|
||||
self.offset += 1;
|
||||
|
||||
if (c == '\n') {
|
||||
self.line += 1;
|
||||
self.column = 0;
|
||||
} else {
|
||||
self.column += 1;
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
fn eat(self: *Parser, char: u8) bool {
|
||||
self.expect(char) catch return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn expect(self: *Parser, expected: u8) !void {
|
||||
if (self.peek()) |actual| {
|
||||
if (expected != actual) {
|
||||
return error.UnexpectedCharacter;
|
||||
}
|
||||
|
||||
_ = self.consumeNoEof();
|
||||
return;
|
||||
}
|
||||
|
||||
return error.UnexpectedEof;
|
||||
}
|
||||
|
||||
fn eatStr(self: *Parser, text: []const u8) bool {
|
||||
self.expectStr(text) catch return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn expectStr(self: *Parser, text: []const u8) !void {
|
||||
if (self.source.len < self.offset + text.len) {
|
||||
return error.UnexpectedEof;
|
||||
} else if (mem.startsWith(u8, self.source[self.offset..], text)) {
|
||||
var i: usize = 0;
|
||||
while (i < text.len) : (i += 1) {
|
||||
_ = self.consumeNoEof();
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
return error.UnexpectedCharacter;
|
||||
}
|
||||
|
||||
fn eatWs(self: *Parser) bool {
|
||||
var ws = false;
|
||||
|
||||
while (self.peek()) |ch| {
|
||||
switch (ch) {
|
||||
' ', '\t', '\n', '\r' => {
|
||||
ws = true;
|
||||
_ = self.consumeNoEof();
|
||||
},
|
||||
else => break,
|
||||
}
|
||||
}
|
||||
|
||||
return ws;
|
||||
}
|
||||
|
||||
fn expectWs(self: *Parser) !void {
|
||||
if (!self.eatWs()) return error.UnexpectedCharacter;
|
||||
}
|
||||
|
||||
fn currentLine(self: Parser) []const u8 {
|
||||
var begin: usize = 0;
|
||||
if (mem.lastIndexOfScalar(u8, self.source[0..self.offset], '\n')) |prev_nl| {
|
||||
begin = prev_nl + 1;
|
||||
}
|
||||
|
||||
const end = mem.indexOfScalarPos(u8, self.source, self.offset, '\n') orelse self.source.len;
|
||||
return self.source[begin..end];
|
||||
}
|
||||
};
|
||||
|
||||
test "xml: Parser" {
|
||||
{
|
||||
var parser = Parser.init("I like pythons");
|
||||
try testing.expectEqual(@as(?u8, 'I'), parser.peek());
|
||||
try testing.expectEqual(@as(u8, 'I'), parser.consumeNoEof());
|
||||
try testing.expectEqual(@as(?u8, ' '), parser.peek());
|
||||
try testing.expectEqual(@as(u8, ' '), try parser.consume());
|
||||
|
||||
try testing.expect(parser.eat('l'));
|
||||
try testing.expectEqual(@as(?u8, 'i'), parser.peek());
|
||||
try testing.expectEqual(false, parser.eat('a'));
|
||||
try testing.expectEqual(@as(?u8, 'i'), parser.peek());
|
||||
|
||||
try parser.expect('i');
|
||||
try testing.expectEqual(@as(?u8, 'k'), parser.peek());
|
||||
try testing.expectError(error.UnexpectedCharacter, parser.expect('a'));
|
||||
try testing.expectEqual(@as(?u8, 'k'), parser.peek());
|
||||
|
||||
try testing.expect(parser.eatStr("ke"));
|
||||
try testing.expectEqual(@as(?u8, ' '), parser.peek());
|
||||
|
||||
try testing.expect(parser.eatWs());
|
||||
try testing.expectEqual(@as(?u8, 'p'), parser.peek());
|
||||
try testing.expectEqual(false, parser.eatWs());
|
||||
try testing.expectEqual(@as(?u8, 'p'), parser.peek());
|
||||
|
||||
try testing.expectEqual(false, parser.eatStr("aaaaaaaaa"));
|
||||
try testing.expectEqual(@as(?u8, 'p'), parser.peek());
|
||||
|
||||
try testing.expectError(error.UnexpectedEof, parser.expectStr("aaaaaaaaa"));
|
||||
try testing.expectEqual(@as(?u8, 'p'), parser.peek());
|
||||
try testing.expectError(error.UnexpectedCharacter, parser.expectStr("pytn"));
|
||||
try testing.expectEqual(@as(?u8, 'p'), parser.peek());
|
||||
try parser.expectStr("python");
|
||||
try testing.expectEqual(@as(?u8, 's'), parser.peek());
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("");
|
||||
try testing.expectEqual(parser.peek(), null);
|
||||
try testing.expectError(error.UnexpectedEof, parser.consume());
|
||||
try testing.expectEqual(parser.eat('p'), false);
|
||||
try testing.expectError(error.UnexpectedEof, parser.expect('p'));
|
||||
}
|
||||
}
|
||||
|
||||
pub const ParseError = error{
|
||||
IllegalCharacter,
|
||||
UnexpectedEof,
|
||||
UnexpectedCharacter,
|
||||
UnclosedValue,
|
||||
UnclosedComment,
|
||||
InvalidName,
|
||||
InvalidEntity,
|
||||
InvalidStandaloneValue,
|
||||
NonMatchingClosingTag,
|
||||
InvalidDocument,
|
||||
OutOfMemory,
|
||||
};
|
||||
|
||||
pub fn parse(backing_allocator: Allocator, source: []const u8) !Document {
|
||||
var parser = Parser.init(source);
|
||||
return try parseDocument(&parser, backing_allocator);
|
||||
}
|
||||
|
||||
fn parseDocument(parser: *Parser, backing_allocator: Allocator) !Document {
|
||||
var doc = Document{
|
||||
.arena = ArenaAllocator.init(backing_allocator),
|
||||
.xml_decl = null,
|
||||
.root = undefined,
|
||||
};
|
||||
|
||||
errdefer doc.deinit();
|
||||
|
||||
const allocator = doc.arena.allocator();
|
||||
|
||||
try skipComments(parser, allocator);
|
||||
|
||||
doc.xml_decl = try parseElement(parser, allocator, .xml_decl);
|
||||
_ = parser.eatWs();
|
||||
try skipComments(parser, allocator);
|
||||
|
||||
doc.root = (try parseElement(parser, allocator, .element)) orelse return error.InvalidDocument;
|
||||
_ = parser.eatWs();
|
||||
try skipComments(parser, allocator);
|
||||
|
||||
if (parser.peek() != null) return error.InvalidDocument;
|
||||
|
||||
return doc;
|
||||
}
|
||||
|
||||
fn parseAttrValue(parser: *Parser, alloc: Allocator) ![]const u8 {
|
||||
const quote = try parser.consume();
|
||||
if (quote != '"' and quote != '\'') return error.UnexpectedCharacter;
|
||||
|
||||
const begin = parser.offset;
|
||||
|
||||
while (true) {
|
||||
const c = parser.consume() catch return error.UnclosedValue;
|
||||
if (c == quote) break;
|
||||
}
|
||||
|
||||
const end = parser.offset - 1;
|
||||
|
||||
return try unescape(alloc, parser.source[begin..end]);
|
||||
}
|
||||
|
||||
fn parseEqAttrValue(parser: *Parser, alloc: Allocator) ![]const u8 {
|
||||
_ = parser.eatWs();
|
||||
try parser.expect('=');
|
||||
_ = parser.eatWs();
|
||||
|
||||
return try parseAttrValue(parser, alloc);
|
||||
}
|
||||
|
||||
fn parseNameNoDupe(parser: *Parser) ![]const u8 {
|
||||
// XML's spec on names is very long, so to make this easier
|
||||
// we just take any character that is not special and not whitespace
|
||||
const begin = parser.offset;
|
||||
|
||||
while (parser.peek()) |ch| {
|
||||
switch (ch) {
|
||||
' ', '\t', '\n', '\r' => break,
|
||||
'&', '"', '\'', '<', '>', '?', '=', '/' => break,
|
||||
else => _ = parser.consumeNoEof(),
|
||||
}
|
||||
}
|
||||
|
||||
const end = parser.offset;
|
||||
if (begin == end) return error.InvalidName;
|
||||
|
||||
return parser.source[begin..end];
|
||||
}
|
||||
|
||||
fn parseCharData(parser: *Parser, alloc: Allocator) !?[]const u8 {
|
||||
const begin = parser.offset;
|
||||
|
||||
while (parser.peek()) |ch| {
|
||||
switch (ch) {
|
||||
'<' => break,
|
||||
else => _ = parser.consumeNoEof(),
|
||||
}
|
||||
}
|
||||
|
||||
const end = parser.offset;
|
||||
if (begin == end) return null;
|
||||
|
||||
return try unescape(alloc, parser.source[begin..end]);
|
||||
}
|
||||
|
||||
fn parseContent(parser: *Parser, alloc: Allocator) ParseError!Content {
|
||||
if (try parseCharData(parser, alloc)) |cd| {
|
||||
return Content{ .char_data = cd };
|
||||
} else if (try parseComment(parser, alloc)) |comment| {
|
||||
return Content{ .comment = comment };
|
||||
} else if (try parseElement(parser, alloc, .element)) |elem| {
|
||||
return Content{ .element = elem };
|
||||
} else {
|
||||
return error.UnexpectedCharacter;
|
||||
}
|
||||
}
|
||||
|
||||
fn parseAttr(parser: *Parser, alloc: Allocator) !?Attribute {
|
||||
const name = parseNameNoDupe(parser) catch return null;
|
||||
_ = parser.eatWs();
|
||||
try parser.expect('=');
|
||||
_ = parser.eatWs();
|
||||
const value = try parseAttrValue(parser, alloc);
|
||||
|
||||
const attr = Attribute{
|
||||
.name = try alloc.dupe(u8, name),
|
||||
.value = value,
|
||||
};
|
||||
return attr;
|
||||
}
|
||||
|
||||
const ElementKind = enum {
|
||||
xml_decl,
|
||||
element,
|
||||
};
|
||||
|
||||
fn parseElement(parser: *Parser, alloc: Allocator, comptime kind: ElementKind) !?*Element {
|
||||
const start = parser.offset;
|
||||
|
||||
const tag = switch (kind) {
|
||||
.xml_decl => blk: {
|
||||
if (!parser.eatStr("<?") or !mem.eql(u8, try parseNameNoDupe(parser), "xml")) {
|
||||
parser.offset = start;
|
||||
return null;
|
||||
}
|
||||
break :blk "xml";
|
||||
},
|
||||
.element => blk: {
|
||||
if (!parser.eat('<')) return null;
|
||||
const tag = parseNameNoDupe(parser) catch {
|
||||
parser.offset = start;
|
||||
return null;
|
||||
};
|
||||
break :blk tag;
|
||||
},
|
||||
};
|
||||
|
||||
var attributes = std.ArrayList(Attribute).init(alloc);
|
||||
defer attributes.deinit();
|
||||
|
||||
var children = std.ArrayList(Content).init(alloc);
|
||||
defer children.deinit();
|
||||
|
||||
while (parser.eatWs()) {
|
||||
const attr = (try parseAttr(parser, alloc)) orelse break;
|
||||
try attributes.append(attr);
|
||||
}
|
||||
|
||||
switch (kind) {
|
||||
.xml_decl => try parser.expectStr("?>"),
|
||||
.element => {
|
||||
if (!parser.eatStr("/>")) {
|
||||
try parser.expect('>');
|
||||
|
||||
while (true) {
|
||||
if (parser.peek() == null) {
|
||||
return error.UnexpectedEof;
|
||||
} else if (parser.eatStr("</")) {
|
||||
break;
|
||||
}
|
||||
|
||||
const content = try parseContent(parser, alloc);
|
||||
try children.append(content);
|
||||
}
|
||||
|
||||
const closing_tag = try parseNameNoDupe(parser);
|
||||
if (!mem.eql(u8, tag, closing_tag)) {
|
||||
return error.NonMatchingClosingTag;
|
||||
}
|
||||
|
||||
_ = parser.eatWs();
|
||||
try parser.expect('>');
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
const element = try alloc.create(Element);
|
||||
element.* = .{
|
||||
.tag = try alloc.dupe(u8, tag),
|
||||
.attributes = try attributes.toOwnedSlice(),
|
||||
.children = try children.toOwnedSlice(),
|
||||
};
|
||||
return element;
|
||||
}
|
||||
|
||||
test "xml: parseElement" {
|
||||
var arena = ArenaAllocator.init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
const alloc = arena.allocator();
|
||||
|
||||
{
|
||||
var parser = Parser.init("<= a='b'/>");
|
||||
try testing.expectEqual(@as(?*Element, null), try parseElement(&parser, alloc, .element));
|
||||
try testing.expectEqual(@as(?u8, '<'), parser.peek());
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("<python size='15' color = \"green\"/>");
|
||||
const elem = try parseElement(&parser, alloc, .element);
|
||||
try testing.expectEqualSlices(u8, elem.?.tag, "python");
|
||||
|
||||
const size_attr = elem.?.attributes[0];
|
||||
try testing.expectEqualSlices(u8, size_attr.name, "size");
|
||||
try testing.expectEqualSlices(u8, size_attr.value, "15");
|
||||
|
||||
const color_attr = elem.?.attributes[1];
|
||||
try testing.expectEqualSlices(u8, color_attr.name, "color");
|
||||
try testing.expectEqualSlices(u8, color_attr.value, "green");
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("<python>test</python>");
|
||||
const elem = try parseElement(&parser, alloc, .element);
|
||||
try testing.expectEqualSlices(u8, elem.?.tag, "python");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[0].char_data, "test");
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("<a>b<c/>d<e/>f<!--g--></a>");
|
||||
const elem = try parseElement(&parser, alloc, .element);
|
||||
try testing.expectEqualSlices(u8, elem.?.tag, "a");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[0].char_data, "b");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[1].element.tag, "c");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[2].char_data, "d");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[3].element.tag, "e");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[4].char_data, "f");
|
||||
try testing.expectEqualSlices(u8, elem.?.children[5].comment, "g");
|
||||
}
|
||||
}
|
||||
|
||||
test "xml: parse prolog" {
|
||||
var arena = ArenaAllocator.init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
const a = arena.allocator();
|
||||
|
||||
{
|
||||
var parser = Parser.init("<?xmla version='aa'?>");
|
||||
try testing.expectEqual(@as(?*Element, null), try parseElement(&parser, a, .xml_decl));
|
||||
try testing.expectEqual(@as(?u8, '<'), parser.peek());
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("<?xml version='aa'?>");
|
||||
const decl = try parseElement(&parser, a, .xml_decl);
|
||||
try testing.expectEqualSlices(u8, "aa", decl.?.getAttribute("version").?);
|
||||
try testing.expectEqual(@as(?[]const u8, null), decl.?.getAttribute("encoding"));
|
||||
try testing.expectEqual(@as(?[]const u8, null), decl.?.getAttribute("standalone"));
|
||||
}
|
||||
|
||||
{
|
||||
var parser = Parser.init("<?xml version=\"ccc\" encoding = 'bbb' standalone \t = 'yes'?>");
|
||||
const decl = try parseElement(&parser, a, .xml_decl);
|
||||
try testing.expectEqualSlices(u8, "ccc", decl.?.getAttribute("version").?);
|
||||
try testing.expectEqualSlices(u8, "bbb", decl.?.getAttribute("encoding").?);
|
||||
try testing.expectEqualSlices(u8, "yes", decl.?.getAttribute("standalone").?);
|
||||
}
|
||||
}
|
||||
|
||||
fn skipComments(parser: *Parser, alloc: Allocator) !void {
|
||||
while ((try parseComment(parser, alloc)) != null) {
|
||||
_ = parser.eatWs();
|
||||
}
|
||||
}
|
||||
|
||||
fn parseComment(parser: *Parser, alloc: Allocator) !?[]const u8 {
|
||||
if (!parser.eatStr("<!--")) return null;
|
||||
|
||||
const begin = parser.offset;
|
||||
while (!parser.eatStr("-->")) {
|
||||
_ = parser.consume() catch return error.UnclosedComment;
|
||||
}
|
||||
|
||||
const end = parser.offset - "-->".len;
|
||||
return try alloc.dupe(u8, parser.source[begin..end]);
|
||||
}
|
||||
|
||||
fn unescapeEntity(text: []const u8) !u8 {
|
||||
const EntitySubstition = struct { text: []const u8, replacement: u8 };
|
||||
|
||||
const entities = [_]EntitySubstition{
|
||||
.{ .text = "<", .replacement = '<' },
|
||||
.{ .text = ">", .replacement = '>' },
|
||||
.{ .text = "&", .replacement = '&' },
|
||||
.{ .text = "'", .replacement = '\'' },
|
||||
.{ .text = """, .replacement = '"' },
|
||||
};
|
||||
|
||||
for (entities) |entity| {
|
||||
if (mem.eql(u8, text, entity.text)) return entity.replacement;
|
||||
}
|
||||
|
||||
return error.InvalidEntity;
|
||||
}
|
||||
|
||||
fn unescape(arena: Allocator, text: []const u8) ![]const u8 {
|
||||
const unescaped = try arena.alloc(u8, text.len);
|
||||
|
||||
var j: usize = 0;
|
||||
var i: usize = 0;
|
||||
while (i < text.len) : (j += 1) {
|
||||
if (text[i] == '&') {
|
||||
const entity_end = 1 + (mem.indexOfScalarPos(u8, text, i, ';') orelse return error.InvalidEntity);
|
||||
unescaped[j] = try unescapeEntity(text[i..entity_end]);
|
||||
i = entity_end;
|
||||
} else {
|
||||
unescaped[j] = text[i];
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
return unescaped[0..j];
|
||||
}
|
||||
|
||||
test "xml: unescape" {
|
||||
var arena = ArenaAllocator.init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
const a = arena.allocator();
|
||||
|
||||
try testing.expectEqualSlices(u8, "test", try unescape(a, "test"));
|
||||
try testing.expectEqualSlices(u8, "a<b&c>d\"e'f<", try unescape(a, "a<b&c>d"e'f<"));
|
||||
try testing.expectError(error.InvalidEntity, unescape(a, "python&"));
|
||||
try testing.expectError(error.InvalidEntity, unescape(a, "python&&"));
|
||||
try testing.expectError(error.InvalidEntity, unescape(a, "python&test;"));
|
||||
try testing.expectError(error.InvalidEntity, unescape(a, "python&boa"));
|
||||
}
|
||||
|
||||
test "xml: top level comments" {
|
||||
var arena = ArenaAllocator.init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
const a = arena.allocator();
|
||||
|
||||
const doc = try parse(a, "<?xml version='aa'?><!--comment--><python color='green'/><!--another comment-->");
|
||||
try testing.expectEqualSlices(u8, "python", doc.root.tag);
|
||||
}
|
||||
|
|
@ -2,12 +2,13 @@
|
|||
|
||||
<head>
|
||||
<link rel="stylesheet" href="style.css" />
|
||||
<!-- <script type="text/javascript" src="https://livejs.com/live.js"></script> -->
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<p id="status-line" class="doublesize">Streamboy is connecting...</p>
|
||||
<p id="gone">[gone]</p>
|
||||
<p id="date"></p>
|
||||
|
||||
<script src="gone.js"></script>
|
||||
</body>
|
||||
|
||||
96
web/gone.js
Normal file
96
web/gone.js
Normal file
|
|
@ -0,0 +1,96 @@
|
|||
// Sunday, February 16 2025, 03:06:20 PM
|
||||
|
||||
const dateElement = document.getElementById("date");
|
||||
|
||||
const months = [
|
||||
"January",
|
||||
"February",
|
||||
"March",
|
||||
"April",
|
||||
"May",
|
||||
"June",
|
||||
"July",
|
||||
"August",
|
||||
"September",
|
||||
"October",
|
||||
"November",
|
||||
"December",
|
||||
];
|
||||
|
||||
const daysOfWeek = [
|
||||
"Sunday",
|
||||
"Monday",
|
||||
"Tuesday",
|
||||
"Wednesday",
|
||||
"Thursday",
|
||||
"Friday",
|
||||
"Saturday",
|
||||
];
|
||||
|
||||
function updateDateTime() {
|
||||
const date = new Date();
|
||||
|
||||
const seconds = date.getSeconds();
|
||||
const minutes = date.getMinutes();
|
||||
const hours24 = date.getHours();
|
||||
const hours12 = hours24 % 12;
|
||||
const ampm = hours24 > 11 && hours24 != 0 ? "PM" : "AM";
|
||||
const secondsString = String(seconds).padStart(2, "0");
|
||||
const minutesString = String(minutes).padStart(2, "0");
|
||||
|
||||
const year = date.getFullYear();
|
||||
const month = months[date.getMonth()];
|
||||
const day = date.getDate();
|
||||
const dayOfWeek = daysOfWeek[date.getDay()];
|
||||
|
||||
dateElement.innerText = `${dayOfWeek}, ${month} ${day} ${year}, ${hours12}:${minutesString}:${secondsString} ${ampm}`;
|
||||
}
|
||||
|
||||
updateDateTime();
|
||||
setInterval(updateDateTime, 1000);
|
||||
|
||||
|
||||
|
||||
// modified stuff from statusline.js
|
||||
// TODO combine both functionalities into the same statusline.js
|
||||
const statusLineElement = document.getElementById("status-line");
|
||||
const statusLineElement2 = statusLineElement.cloneNode();
|
||||
statusLineElement2.id = "status-line2";
|
||||
document.body.appendChild(statusLineElement2);
|
||||
|
||||
let status = { blocks: [{ text: "Streamboy is connecting...", color: "#ffffff" }] };
|
||||
let scroll = 0;
|
||||
|
||||
setInterval(() => {
|
||||
let string = "";
|
||||
for (const i in status.blocks) {
|
||||
string += status.blocks[i].text;
|
||||
if (i < status.blocks.length - 1) string += " | ";
|
||||
}
|
||||
|
||||
if (scroll >= string.length + 9) scroll = 0;
|
||||
const stringWidth = 16 * string.length + 144;
|
||||
if (16 * string.length <= statusLineElement.parentElement.clientWidth) {
|
||||
scroll = 0;
|
||||
statusLineElement.style.removeProperty("position");
|
||||
statusLineElement.style.removeProperty("left");
|
||||
statusLineElement2.style.display = "none";
|
||||
statusLineElement.textContent = string;
|
||||
statusLineElement2.textContent = string;
|
||||
} else {
|
||||
statusLineElement.style.position = "absolute";
|
||||
statusLineElement.style.left = `${-16 * scroll}px`;
|
||||
statusLineElement2.style.position = "absolute";
|
||||
statusLineElement2.style.left = `${-16 * scroll + stringWidth}px`;
|
||||
statusLineElement2.style.removeProperty("display");
|
||||
scroll += 1;
|
||||
statusLineElement.textContent = string + " | ";
|
||||
statusLineElement2.textContent = string + " | ";
|
||||
}
|
||||
}, 500);
|
||||
|
||||
const socket = new WebSocket("ws://localhost:8012");
|
||||
|
||||
socket.addEventListener("message", (event) => {
|
||||
status = JSON.parse(event.data);
|
||||
});
|
||||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
<head>
|
||||
<link rel="stylesheet" href="style.css" />
|
||||
<!-- <script type="text/javascript" src="https://livejs.com/live.js"></script> -->
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<p id="status-line"></p>
|
||||
<p id="status-line">Streamboy is connecting...</p>
|
||||
|
||||
<script src="statusline.js"></script>
|
||||
</body>
|
||||
|
||||
41
web/statusline.js
Normal file
41
web/statusline.js
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
const statusLineElement = document.getElementById("status-line");
|
||||
const statusLineElement2 = statusLineElement.cloneNode();
|
||||
statusLineElement2.id = "status-line2";
|
||||
document.body.appendChild(statusLineElement2);
|
||||
|
||||
let status = { blocks: [{ text: "Streamboy is connecting...", color: "#ffffff" }] };
|
||||
let scroll = 0;
|
||||
|
||||
setInterval(() => {
|
||||
let string = "";
|
||||
for (const i in status.blocks) {
|
||||
string += status.blocks[i].text;
|
||||
if (i < status.blocks.length - 1) string += " | ";
|
||||
}
|
||||
|
||||
if (scroll >= string.length + 9) scroll = 0;
|
||||
const stringWidth = 8 * string.length + 72;
|
||||
if (8 * string.length <= statusLineElement.parentElement.clientWidth) {
|
||||
scroll = 0;
|
||||
statusLineElement.style.removeProperty("position");
|
||||
statusLineElement.style.removeProperty("left");
|
||||
statusLineElement2.style.display = "none";
|
||||
statusLineElement.textContent = string;
|
||||
statusLineElement2.textContent = string;
|
||||
} else {
|
||||
statusLineElement.style.position = "absolute";
|
||||
statusLineElement.style.left = `${-8 * scroll}px`;
|
||||
statusLineElement2.style.position = "absolute";
|
||||
statusLineElement2.style.left = `${-8 * scroll + stringWidth}px`;
|
||||
statusLineElement2.style.removeProperty("display");
|
||||
scroll += 1;
|
||||
statusLineElement.textContent = string + " | ";
|
||||
statusLineElement2.textContent = string + " | ";
|
||||
}
|
||||
}, 500);
|
||||
|
||||
const socket = new WebSocket("ws://localhost:8012");
|
||||
|
||||
socket.addEventListener("message", (event) => {
|
||||
status = JSON.parse(event.data);
|
||||
});
|
||||
43
web/style.css
Normal file
43
web/style.css
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
body {
|
||||
font-family: Unifont;
|
||||
background-color: black;
|
||||
color: white;
|
||||
margin: 0px auto;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
#gone {
|
||||
font-size: 224px;
|
||||
position: absolute;
|
||||
bottom: 164px;
|
||||
left: 44px;
|
||||
margin: 0;
|
||||
background: linear-gradient(#179d23, #0f552c);
|
||||
color: transparent;
|
||||
background-clip: text;
|
||||
}
|
||||
|
||||
#date {
|
||||
font-size: 64px;
|
||||
position: absolute;
|
||||
left: 96px;
|
||||
bottom: 64px;
|
||||
margin: 0px;
|
||||
background: linear-gradient(#26677d, #264f9a);
|
||||
color: transparent;
|
||||
background-clip: text;
|
||||
}
|
||||
|
||||
#status-line, #status-line2 {
|
||||
font-size: 16px;
|
||||
margin: 0px;
|
||||
white-space: preserve nowrap;
|
||||
max-width: none;
|
||||
text-align: center;
|
||||
position: absolute;
|
||||
}
|
||||
|
||||
.doublesize {
|
||||
font-size: 32px !important;
|
||||
margin-top: 64px !important;
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue