3 Commits

Author SHA1 Message Date
d26a88628b boiler plating 2025-03-02 17:04:31 -05:00
d499e013f5 move vite-plugin-html into devDependencies 2025-03-02 16:04:28 -05:00
b64ccd6975 add vite-plugin-ejs 2025-03-02 15:36:01 -05:00
14 changed files with 178 additions and 414 deletions

View File

@ -11,7 +11,8 @@
"devDependencies": { "devDependencies": {
"sass": "^1.85.1", "sass": "^1.85.1",
"typescript": "^5.8.2", "typescript": "^5.8.2",
"vite": "^6.2.1", "vite": "^6.2.0",
"vite-plugin-html": "^3.2.2" "vite-plugin-html": "^3.2.2",
"vite-plugin-ejs": "^1.7.0"
} }
} }

11
src/html/footer.html Normal file
View File

@ -0,0 +1,11 @@
<p class="raw-text" id="time">00:00:00</p>
<section>
<p class="raw-text" id="column-line">0, 0</p>
<button id="toggle-monospace">Monospace</button>
<button id="toggle-term-mode">UNIX</button>
</section>
<noscript>
<style>
#toggle-monospace, .raw-text { display: none }
</style>
</noscript>

14
src/html/header.html Normal file
View File

@ -0,0 +1,14 @@
<button class="header-left">
<a href="https://rhpidfyre.io/" class="header-button">[rhpidfyre.io]</a>
</button>
<section class="header-right">
<button>
<a href="https://git.rhpidfyre.io/" class="header-button">GIT</a>
</button>
<button>
<a href="https://files.rhpidfyre.io/" class="header-button">CLOUD</a>
</button>
<button>
<a href="https://gsm.rhpidfyre.io/" class="header-button">GSM</a>
</button>
</section>

17
src/html/motd.html Normal file
View File

@ -0,0 +1,17 @@
<p>Welcome to rhpidfyre.io!</p>
<div class="return"></div>
<p>This is a personal website by rhpidfyre / Brandon.</p>
<p>You can find my services here or learn about me.</p>
<div class="return"></div>
<p>You can also contribute or view the source code of my website via the links:</p>
<p>&lt;<a href="https://git.rhpidfyre.io/rhpidfyre/rhpidfyre.io" target="_blank">https://git.rhpidfyre.io/rhpidfyre/rhpidfyre.io</a>&gt;.</p>
<p>&lt;<a href="https://github.com/unixtensor/rhpidfyre.io" target="_blank">https://github.com/unixtensor/rhpidfyre.io</a>&gt;.</p>
<div class="return"></div>
<p>You can get started with the command: <span class="bold">help</span></p>
<div class="return"></div>
<noscript>
<p><span class="red">=================================================</span></p>
<p><span class="red">JavaScript is disabled, functionality will be limited. :(</span></p>
<p><span class="red">But, you will not be limited at exploring my services which you can find by navigating towards the top-right.</span></p>
<p><span class="red">=================================================</span></p>
</noscript>

22
src/index.ejs Normal file
View File

@ -0,0 +1,22 @@
<!doctype html>
<html>
<head>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width"/>
<link rel="icon" type="image/png" href="/logo.png"/>
<link rel="stylesheet" href="./scss/global.scss"/>
<title>rhpidfyre.io</title>
</head>
<body>
<header>
<%- inlineHtml("header") %>
</header>
<main>
<%- inlineHtml("motd") %>
</main>
<footer>
<%- inlineHtml("footer") %>
</footer>
<script type="module" src="./rt/emulator/terminal.ts"></script>
</body>
</html>

View File

@ -1,61 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width"/>
<link rel="icon" type="image/png" href="/logo.png"/>
<link rel="stylesheet" href="./scss/global.scss"/>
<title>rhpidfyre.io</title>
</head>
<body>
<header>
<button class="header-left">
<a href="https://rhpidfyre.io/" class="header-button">[rhpidfyre.io]</a>
</button>
<section class="header-right">
<button>
<a href="https://git.rhpidfyre.io/" class="header-button">GIT</a>
</button>
<button>
<a href="https://files.rhpidfyre.io/" class="header-button">CLOUD</a>
</button>
<button>
<a href="https://gsm.rhpidfyre.io/" class="header-button">GSM</a>
</button>
</section>
</header>
<main>
<p>Welcome to rhpidfyre.io!</p>
<div class="return"></div>
<p>This is a personal website by rhpidfyre / Brandon.</p>
<p>You can find my services here or learn about me.</p>
<div class="return"></div>
<p>You can also contribute or view the source code of my website via the links:</p>
<p>&lt;<a href="https://git.rhpidfyre.io/rhpidfyre/rhpidfyre.io" target="_blank">https://git.rhpidfyre.io/rhpidfyre/rhpidfyre.io</a>&gt;.</p>
<p>&lt;<a href="https://github.com/unixtensor/rhpidfyre.io" target="_blank">https://github.com/unixtensor/rhpidfyre.io</a>&gt;.</p>
<div class="return"></div>
<p>You can get started with the command: <span class="bold">help</span></p>
<div class="return"></div>
<noscript>
<p><span class="red">=================================================</span></p>
<p><span class="red">JavaScript is disabled, functionality will be limited. :(</span></p>
<p><span class="red">But, you will not be limited at exploring my services which you can find by navigating towards the top-right.</span></p>
<p><span class="red">=================================================</span></p>
</noscript>
</main>
<footer>
<p class="raw-text" id="time">00:00:00</p>
<section>
<p class="raw-text" id="column-line">0, 0</p>
<button id="toggle-monospace">Monospace</button>
<button id="toggle-term-mode">UNIX</button>
</section>
<noscript>
<style>
#toggle-monospace, .raw-text { display: none }
</style>
</noscript>
</footer>
<script type="module" src="./rt/emulator/terminal.ts"></script>
</body>
</html>

View File

@ -0,0 +1,46 @@
import { type Entry } from "./main"
import entry_search from "./index"
type Files<T> = Entry<T>[]
interface EntryCollectionManipulate {
pop: <T extends Entry<T>>(file_name: string) => Entry<T> | undefined,
get: <T extends Entry<T>>(file_name: string) => Entry<T> | undefined
push: <T extends Entry<T>>(entry: Entry<T>) => boolean,
sort: () => void,
}
interface EntryCollection<T> extends EntryCollectionManipulate {
readonly inner: Files<T>
}
function entry_trait<T extends Entry<T>>() {
const trait = {} as EntryCollection<T>
trait.sort = function() {
this.inner.sort((a,z) => a.name.localeCompare(z.name))
}
trait.push = function(entry) {
const no_duplicates = entry_search(this.inner, entry.name)
if (!no_duplicates) {
this.push(entry)
this.sort()
return true
}
return false
}
trait.pop = function(file_name) {
const file_search = entry_search(this.inner, file_name)
if (file_search) {
this.inner.splice(file_search.index, 1)
return file_search.result
}
return
}
return trait
}
export {
entry_trait,
type EntryCollection,
type Files,
}

View File

@ -1,47 +0,0 @@
type ConstEnum = number
const enum EntryType {
Directory,
Binary,
File,
}
const enum Permissions {
r,
w,
rw,
none,
}
const enum PermissionsBinary {
r,
w,
x,
rw,
rwx,
rx,
wx,
none,
}
const enum PushStatus {
Ok,
Duplicate,
Denied,
}
const enum ReadStatus {
Ok,
NotFound,
Denied,
}
const enum Result {
None,
Ok,
}
export {
type ConstEnum,
PermissionsBinary,
Permissions,
PushStatus,
ReadStatus,
EntryType,
Result,
}

View File

@ -1,41 +0,0 @@
import { Permissions } from "../enum"
import rfwfs from "../main"
const time_now = (Date.now()/1000)|0
// ------------ Home ------------
const config = rfwfs.directory(".config", Permissions.rw, time_now)
const local = rfwfs.directory(".local", Permissions.rw, time_now)
const downloads = rfwfs.directory("Downloads", Permissions.rw, time_now)
const pictures = rfwfs.directory("Pictures", Permissions.rw, time_now)
const desktop = rfwfs.directory("Desktop", Permissions.rw, time_now)
const videos = rfwfs.directory("Videos", Permissions.rw, time_now)
const music = rfwfs.directory("Music", Permissions.rw, time_now)
const user = rfwfs.directory("user", Permissions.r, time_now, [
config,
local,
downloads,
pictures,
videos,
music,
desktop,
])
// /home/
const home = rfwfs.directory("home", Permissions.r, time_now, [user])
// ------------
// ------------ root ------------
const bin = rfwfs.directory("bin", Permissions.r, time_now)
const vard = rfwfs.directory("var", Permissions.r, time_now)
const etc = rfwfs.directory("etc", Permissions.r, time_now)
// ------------
export default rfwfs.directory("/", Permissions.r, time_now, [
bin,
home,
vard,
etc,
])

View File

@ -1,51 +0,0 @@
import { type FileInner } from "./main"
interface HashTable {
[index: string]: FileInner
}
interface Hash {
readonly inner: HashTable,
sha256: (file_inner: FileInner) => Promise<string>,
push: (hash: string) => void,
find: (hash: string) => FileInner | undefined,
pop: (hash: string) => FileInner | undefined,
}
async function sha256(inner_as_string: string): Promise<string> {
const encoder = new TextEncoder()
const hash = await crypto.subtle.digest("SHA-256", encoder.encode(inner_as_string))
const hash_as_uint8 = new Uint8Array(hash)
return Array.from(hash_as_uint8).map(byte => byte.toString(16).padStart(2, "0")).join("")
}
const hash_table = { inner: {} } as Hash
hash_table.sha256 = async function(file_inner) {
return await sha256(file_inner.toString())
}
hash_table.find = function(hash) {
const hash_entry = this.inner[hash]
if (hash_entry) {
return hash_entry
}
return undefined
}
hash_table.pop = function(hash) {
const hash_entry = this.find(hash)
if (hash_entry) {
delete this.inner[hash_entry]
return hash_entry
}
return undefined
}
hash_table.push = function(hash) {
}
export default hash_table
export {
type HashTable,
}

View File

@ -1,15 +1,23 @@
import { type Entry } from "./main" import { type Entry } from "./main"
import { wrap_bsearch, type WrapBSearch } from "./wrap" import { type Files } from "./collection"
export default function directory_search<T extends Entry>(entry_collection: T[], file_name: string): WrapBSearch<T> | undefined { interface SearchResult<T> {
readonly result: T,
readonly index: number
}
function wrap_result<T>(result: T, index: number): SearchResult<T> {
return { result: result, index: index }
}
export default function entry_search<T>(cloned_file_collection: Files<T>, file_name: string): SearchResult<Entry<T>> | undefined {
let start = 0 let start = 0
let end = entry_collection.length-1 let end = cloned_file_collection.length-1
while (start<=end) { while (start<=end) {
const median = (start+end)>>1 const median = (start+end)>>1
const median_name = entry_collection[median].name const median_name = cloned_file_collection[median].name
if (median_name === file_name) { if (median_name == file_name) { //left == right && (T == U) is not necessary
return wrap_bsearch(median, entry_collection[median]) return wrap_result(cloned_file_collection[median], median)
} else if (median_name<file_name) { } else if (median_name<file_name) {
start = median+1 start = median+1
} else { } else {

View File

@ -1,180 +1,47 @@
import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum" import { type EntryCollection } from "./collection"
import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
import directory_search from "./index" const enum EntryType {
import hash_table from "./hash" Directory,
File
type FileInner = string | number
type EntryFileInner = EntryValue<FileInner, FileInner | undefined>
//please do not change the inner values directly on entries or else there will be catastrophic consequences
interface EntryValue<T, U = T> {
__inner: T,
write: (value: T) => boolean,
read: () => U,
} }
interface Entry { const enum Permissions {
permissions: Permissions, r,
timestamp: EntryValue<number>, w,
name: EntryValue<string>, rw,
none
}
interface Entry<T> {
readonly name: string,
readonly type: EntryType, readonly type: EntryType,
} readonly inner: T,
interface EntryFile extends Entry { readonly timestamp: number,
inner: EntryFileInner, readonly collection?: EntryCollection<T>,
hash: string, readonly permissions: Permissions,
}
interface EntryCollection<T extends Entry> extends Entry {
inner: EntryCollectionManipulate<T>,
}
interface EntryCollectionManipulate<T extends Entry> {
__inner: T[],
clone: (file_name: string) => WrapResultEntry<T, ReadStatus>
find: (file_name: string) => WrapResultEntry<T, ReadStatus>
push: (entry: Entry) => WrapResultNone<PushStatus>,
sort: () => void,
pop: (file_name: string) => WrapResultEntry<T, ReadStatus>,
} }
interface Rfwfs { interface Rfwfs {
directory: <T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]) => EntryCollection<T>, new_entry: <T extends Entry<T>>(name: string, permissions: Permissions, timestamp: number, inner: T) => Entry<T>,
file: (default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: FileInner) => Promise<EntryFile>, entry_trait: <T extends Entry<T>>(inner: T) => EntryCollection<T>
is_binary: <T extends Entry>(entry: T) => boolean, new_entry_tree: <T>(files: T) => T,
is_file: <T extends Entry>(entry: T) => boolean,
is_dir: <T extends Entry>(entry: T) => boolean,
}
function execute_access<P extends ConstEnum>(permissions: P): boolean {
return permissions === PermissionsBinary.rwx
|| permissions === PermissionsBinary.rx
|| permissions === PermissionsBinary.wx
|| permissions === PermissionsBinary.x
}
function read_write_access<P extends ConstEnum>(permissions: P): boolean {
return permissions === Permissions.rw
}
function read_access<P extends ConstEnum>(permissions: P): boolean {
return read_write_access(permissions) || permissions === Permissions.r
}
function write_access<P extends ConstEnum>(permissions: P): boolean {
return read_write_access(permissions) || permissions === Permissions.w
}
function directory_sort<E extends Entry>(self: EntryCollectionManipulate<E>) {
self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
}
function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> {
if (write_access(self.permissions)) {
const no_duplicates = directory_search(self.inner.__inner, entry.name.read())
if (!no_duplicates) {
self.inner.__inner.push(entry)
self.inner.__inner.sort()
return wrap_none(PushStatus.Ok)
}
return wrap_none(PushStatus.Duplicate)
}
return wrap_none(PushStatus.Denied)
}
function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
if (read_access(self.permissions)) {
const file_search = directory_search(self.inner.__inner, file_name)
if (file_search) {
return wrap_entry(ReadStatus.Ok, file_search.result)
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
}
function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
if (read_write_access(self.permissions)) {
const pop_find = directory_search(self.inner.__inner, file_name)
if (pop_find) {
self.inner.__inner.splice(pop_find.some, 1)
return wrap_entry(ReadStatus.Ok, pop_find.result)
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
}
function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
if (read_write_access(self.permissions)) {
const clone_find = directory_search(self.inner.__inner, file_name)
if (clone_find) {
return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
}
return wrap_entry(ReadStatus.NotFound)
}
return wrap_entry(ReadStatus.Denied)
}
function inner_read<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P): FileInner | undefined {
return read_access(permissions) ? self.__inner : undefined
}
function inner_write<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P, item: I): boolean {
if (write_access(permissions)) {
self.__inner = item
return true
}
return false
}
function inner<P extends ConstEnum, I, R extends EntryValue<I>>(permissions: P, inner_default: I): R {
const inner_trait = { __inner: inner_default } as R
inner_trait.write = function(item) { return inner_write(this, permissions, item) }
inner_trait.read = function() { return inner_read(this, permissions) }
return inner_trait
}
function dir_inner<T extends Entry>(self: EntryCollection<T>, collection: T[]): EntryCollectionManipulate<T> {
const collection_trait = { __inner: collection } as EntryCollectionManipulate<T>
collection_trait.clone = function(file_name) { return directory_clone(self, file_name) }
collection_trait.find = function(file_name) { return directory_find(self, file_name) }
collection_trait.push = function(entry) { return directory_push(self, entry) }
collection_trait.sort = function() { return directory_sort(this) }
collection_trait.pop = function(file_name) { return directory_pop(self, file_name) }
collection_trait.sort() //the default collection is automatically sorted on directory creation.
return collection_trait
} }
const rfwfs = {} as Rfwfs const rfwfs = {} as Rfwfs
rfwfs.is_dir = function(entry) { rfwfs.new_entry = function(name, permissions, timestamp, inner) {
return entry.type === EntryType.Directory const file_type = typeof inner == "object" ? EntryType.Directory : EntryType.File
return {
name: name,
type: file_type,
inner: inner,
timestamp: timestamp ? timestamp : Math.floor(Date.now()/1000),
collection: file_type === EntryType.Directory ? this.entry_trait(inner) : undefined,
permissions: permissions,
} }
rfwfs.is_file = function(entry) {
return entry.type === EntryType.File
}
rfwfs.is_binary = function(entry) {
return entry.type === EntryType.Binary
} }
rfwfs.file = async function(default_name, default_permissions, default_timestamp, default_inner = "") {
const file = { type: EntryType.File } as EntryFile
file.permissions = default_permissions
file.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
file.inner = inner(default_permissions, default_inner)
file.name = inner(default_permissions, default_name)
file.hash = await hash_table.sha256(default_inner)
return file
}
rfwfs.directory = function<T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]): EntryCollection<T> {
const directory = { type: EntryType.Directory } as EntryCollection<T>
directory.permissions = default_permissions
directory.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
directory.inner = inner(default_permissions, default_inner)
directory.name = inner(default_permissions, default_name)
return directory
}
export default rfwfs
export { export {
type EntryCollectionManipulate, EntryType,
Permissions,
type EntryCollection, type EntryCollection,
type FileInner,
type EntryFile,
type Entry, type Entry,
} }

View File

@ -1,40 +0,0 @@
import { Result, type ConstEnum } from "./enum"
import { type Entry } from "./main"
type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
type WrapBSearch<T extends Entry> = WrapResult<T, number>
type WrapResultNone<T> = WrapResult<Result.None, T>
interface WrapResult<T, U> {
/** The resulting value if `U` is a success */
readonly result: T,
/** Represents some arbitrary extra value, usually a success status */
readonly some: U
}
function wrap<T, U>(result: T, some: U): WrapResult<T, U> {
return { result: result, some: some }
}
function wrap_bsearch<T extends Entry>(index: number, result: T): WrapBSearch<T> {
return wrap(result, index)
}
function wrap_entry<T extends ConstEnum, U extends Entry>(status: T, result?: U): WrapResultEntry<U, T> {
return wrap(result, status)
}
function wrap_none<T extends ConstEnum>(status: T): WrapResultNone<T> {
return wrap(Result.None, status)
}
export default wrap
export {
wrap_bsearch,
wrap_entry,
wrap_none,
type WrapResultEntry,
type WrapResultNone,
type WrapBSearch,
type WrapResult,
}

View File

@ -1,9 +1,27 @@
import { defineConfig } from 'vite' import { defineConfig } from 'vite'
import { createHtmlPlugin } from 'vite-plugin-html' import { createHtmlPlugin } from 'vite-plugin-html'
import { ViteEjsPlugin } from 'vite-plugin-ejs'
import fs from "fs"
import path from "path"
const html_dir = path.join(__dirname, "src", "html")
function inlineHtml(html_file_name) {
try {
const html_path = path.resolve(path.join(html_dir, html_file_name+".html"))
return fs.readFileSync(html_path, "utf-8")
} catch(read_err) {
return "[INLINE-ERROR], "+read_err
}
}
export default defineConfig({ export default defineConfig({
plugins: [ plugins: [
createHtmlPlugin({minify: true}), createHtmlPlugin({minify: true}),
ViteEjsPlugin({
inlineHtml: inlineHtml
})
], ],
root: "src", root: "src",
build: { build: {