Compare commits
1 Commits
rfwfs-libr
...
f8cddaf340
| Author | SHA1 | Date | |
|---|---|---|---|
| f8cddaf340 |
13
package.json
13
package.json
@ -1,16 +1,17 @@
|
||||
{
|
||||
"name": "rhpidfyre.io",
|
||||
"version": "0.0.1",
|
||||
"private": true,
|
||||
"version": "0.0.1",
|
||||
"type": "module",
|
||||
"devDependencies": {
|
||||
"sass": "^1.89.0",
|
||||
"typescript": "^5.8.3",
|
||||
"vite": "^6.3.5"
|
||||
},
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
"build": "tsc && vite build",
|
||||
"preview": "vite preview"
|
||||
},
|
||||
"devDependencies": {
|
||||
"sass": "^1.85.0",
|
||||
"typescript": "^5.7.3",
|
||||
"vite": "^6.1.1",
|
||||
"vite-plugin-html": "^3.2.2"
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8"/>
|
||||
<meta name="viewport" content="width=device-width"/>
|
||||
@ -56,6 +56,6 @@
|
||||
</style>
|
||||
</noscript>
|
||||
</footer>
|
||||
<script type="module" src="./rt/emulator/terminal.ts"></script>
|
||||
<script type="module" src="./rt/terminal.ts"></script>
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 5.7 KiB After Width: | Height: | Size: 70 KiB |
@ -1,24 +0,0 @@
|
||||
interface SHA256 {
|
||||
readonly secret: string
|
||||
}
|
||||
|
||||
class Crypto {
|
||||
protected inner: string
|
||||
|
||||
constructor(inner: string) {
|
||||
this.inner = inner
|
||||
}
|
||||
|
||||
public async sha256_hash(): Promise<SHA256> {
|
||||
const encoder = new TextEncoder()
|
||||
const hash = await crypto.subtle.digest("SHA-256", encoder.encode(this.inner))
|
||||
const hash_as_uint8 = new Uint8Array(hash)
|
||||
|
||||
return { secret: Array.from(hash_as_uint8).map(byte => byte.toString(16).padStart(2, "0")).join("") }
|
||||
}
|
||||
}
|
||||
|
||||
export default Crypto
|
||||
export {
|
||||
type SHA256
|
||||
}
|
||||
@ -1,6 +1,6 @@
|
||||
import { cyan, green } from "../shell/color"
|
||||
import { get_working_dir_name } from "../shell/fs/fn"
|
||||
|
||||
import librfwfs, { username } from "../rfwfs/library"
|
||||
import create from "./create"
|
||||
|
||||
interface Ps1Prompt {
|
||||
@ -43,20 +43,14 @@ function ps1_element(user: HTMLSpanElement, dir: HTMLSpanElement) {
|
||||
return display
|
||||
}
|
||||
|
||||
function working_dir_name() {
|
||||
const dir = librfwfs.home.dir()
|
||||
if (dir) {
|
||||
const dir_name = dir.name.read()
|
||||
if (dir_name) {
|
||||
return dir_name === username ? "~" : dir_name
|
||||
}
|
||||
}
|
||||
return "?"
|
||||
function working_dir() {
|
||||
const dir_name = get_working_dir_name()
|
||||
return dir_name === "user" ? "~" : dir_name
|
||||
}
|
||||
|
||||
function working_dir_element() {
|
||||
const user = cyan("user")
|
||||
const dir = green(" "+working_dir_name())
|
||||
const dir = green(" "+working_dir())
|
||||
return ps1_element(user, dir)
|
||||
}
|
||||
|
||||
|
||||
@ -26,12 +26,6 @@ function stdout_grid<T extends HTMLElement>(left: string[], right: string[], hea
|
||||
return wrap_indicator
|
||||
}
|
||||
|
||||
function stdout_horizontal_elements<T extends HTMLElement>(elements: T[]) {
|
||||
const h_elements_out = horizontal()
|
||||
h_elements_out.append(...elements)
|
||||
return h_elements_out
|
||||
}
|
||||
|
||||
function stdout_horizontal(strs: string[]) {
|
||||
const p = create("p")
|
||||
strs.forEach((str, i) => {
|
||||
@ -54,8 +48,7 @@ export default function stdout(str: string) {
|
||||
}
|
||||
|
||||
export {
|
||||
stdout_horizontal_elements,
|
||||
stdout_horizontal,
|
||||
stdout_grid,
|
||||
stdout_horizontal,
|
||||
stdout_bold
|
||||
}
|
||||
15
src/rt/fs.ts
15
src/rt/fs.ts
@ -1,15 +0,0 @@
|
||||
import rfwfs, { PERMISSION_FLAGS } from "./rfwfs/main"
|
||||
|
||||
const time_now = (Date.now()/1000) | 0
|
||||
const fs = new rfwfs()
|
||||
|
||||
const root = fs.push_bulk_unsafe([
|
||||
rfwfs.directory_in_root({
|
||||
permissions: {wheel: PERMISSION_FLAGS.RWX, users: PERMISSION_FLAGS.NONE},
|
||||
timestamp: time_now,
|
||||
metadata: {},
|
||||
name: "bin"
|
||||
})
|
||||
])
|
||||
|
||||
export default fs
|
||||
@ -1,5 +1,5 @@
|
||||
import run from "../shell/command/command"
|
||||
import history from "../shell/history"
|
||||
import run from "./shell/command/command"
|
||||
import history from "./shell/history"
|
||||
|
||||
type InputClosure = (key_event: KeyboardEvent) => void
|
||||
interface EnterArgs {
|
||||
@ -1,179 +0,0 @@
|
||||
import { ROOT_ID } from "./main";
|
||||
|
||||
import wrap, { type WrapResult } from "./wrap";
|
||||
import User from "./users";
|
||||
|
||||
type User_Index = [User, number]
|
||||
type WrapUserSearch = WrapResult<User_Index | undefined, GroupSearch>
|
||||
|
||||
type SysGroupsNames = "wheel" | "users"
|
||||
|
||||
const enum SysGroups {
|
||||
Wheel,
|
||||
Users,
|
||||
}
|
||||
const enum UserMoveStatus {
|
||||
Ok,
|
||||
RootBlocked,
|
||||
MovingNonExistentUser,
|
||||
AlreadyInWheel,
|
||||
AlreadyInUsers,
|
||||
}
|
||||
const enum GroupRemoveStatus {
|
||||
Ok,
|
||||
RootBlocked,
|
||||
RemovingNonExistentUser,
|
||||
}
|
||||
const enum GroupSearch {
|
||||
NotFound,
|
||||
WheelResult,
|
||||
UsersResult,
|
||||
}
|
||||
|
||||
interface Groups {
|
||||
wheel: Group,
|
||||
users: Group,
|
||||
together: () => User[]
|
||||
}
|
||||
|
||||
class Group {
|
||||
protected inner: User[];
|
||||
private group_type: SysGroups;
|
||||
|
||||
constructor(type: SysGroups) {
|
||||
this.group_type = type
|
||||
this.inner = []
|
||||
}
|
||||
|
||||
public users(): User[] {
|
||||
return [...this.inner]
|
||||
}
|
||||
public type(): SysGroups {
|
||||
return this.group_type
|
||||
}
|
||||
public type_as_name(): SysGroupsNames {
|
||||
return this.type() === SysGroups.Wheel ? "wheel" : "users"
|
||||
}
|
||||
|
||||
public add_user(user: User): boolean {
|
||||
const duplicate = this.inner.find(user_in_group => user_in_group.uname() === user.uname())
|
||||
if (!duplicate) {
|
||||
this.inner.push(user)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
public remove_user(user: User): User | undefined {
|
||||
for (let i = 0; i<this.inner.length; i++) {
|
||||
if (this.inner[i].uname() === user.uname()) {
|
||||
this.inner.splice(i, 1)
|
||||
return this.inner[i]
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
}
|
||||
|
||||
const groups: Groups = {
|
||||
wheel: new Group(SysGroups.Wheel),
|
||||
users: new Group(SysGroups.Users),
|
||||
together: function() {
|
||||
return [...this.wheel.users(), ...this.users.users()]
|
||||
}
|
||||
}
|
||||
|
||||
function wrap_user_search(status: GroupSearch, result?: User_Index): WrapUserSearch {
|
||||
return wrap(result, status)
|
||||
}
|
||||
|
||||
function group_iter_for_user(uname: string, group_t: Group): User_Index | undefined {
|
||||
const group_t_users = group_t.users()
|
||||
for (let i = 0; i<group_t_users.length; i++) {
|
||||
if (group_t_users[i].uname() === uname) {
|
||||
return [group_t_users[i], i]
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
function groups_find_user(uname: string): WrapUserSearch {
|
||||
const exist_in_wheel = group_iter_for_user(uname, groups.wheel)
|
||||
if (exist_in_wheel) {
|
||||
return wrap_user_search(GroupSearch.WheelResult, exist_in_wheel)
|
||||
}
|
||||
const exist_in_users = group_iter_for_user(uname, groups.users)
|
||||
if (exist_in_users) {
|
||||
return wrap_user_search(GroupSearch.UsersResult, exist_in_users)
|
||||
}
|
||||
return wrap_user_search(GroupSearch.NotFound)
|
||||
}
|
||||
|
||||
function group_add(new_user: User, group_t: Group): GroupSearch {
|
||||
const dups = groups_find_user(new_user.uname())
|
||||
if (dups.status === GroupSearch.NotFound) {
|
||||
group_t.add_user(new_user)
|
||||
}
|
||||
return dups.status
|
||||
}
|
||||
|
||||
function group_remove(uname: string, group_t: Group): GroupRemoveStatus {
|
||||
if (uname !== ROOT_ID.NAME) {
|
||||
const found_user = group_t.users().find(user => user.uname() === uname)
|
||||
if (found_user) {
|
||||
group_t.remove_user(found_user)
|
||||
return GroupRemoveStatus.Ok
|
||||
}
|
||||
return GroupRemoveStatus.RemovingNonExistentUser
|
||||
}
|
||||
return GroupRemoveStatus.RootBlocked
|
||||
}
|
||||
|
||||
function group_user_move(uname: string, new_group: SysGroups): UserMoveStatus {
|
||||
if (uname === ROOT_ID.NAME) { return UserMoveStatus.RootBlocked }
|
||||
|
||||
const find_in_group = groups_find_user(uname)
|
||||
if (find_in_group.status === GroupSearch.NotFound) { return UserMoveStatus.MovingNonExistentUser }
|
||||
|
||||
if (new_group === SysGroups.Wheel) {
|
||||
if (find_in_group.status === GroupSearch.WheelResult) { return UserMoveStatus.AlreadyInWheel }
|
||||
|
||||
groups.wheel.add_user(groups.users.remove_user((find_in_group.result as User_Index)[0]) as User)
|
||||
} else if (new_group === SysGroups.Users) {
|
||||
if (find_in_group.status === GroupSearch.UsersResult) { return UserMoveStatus.AlreadyInUsers }
|
||||
|
||||
groups.users.add_user(groups.wheel.remove_user((find_in_group.result as User_Index)[0]) as User)
|
||||
}
|
||||
return UserMoveStatus.Ok
|
||||
}
|
||||
|
||||
function group_wheel_add(new_user: User): GroupSearch {
|
||||
return group_add(new_user, groups.wheel)
|
||||
}
|
||||
|
||||
function group_wheel_remove(uname: string): GroupRemoveStatus {
|
||||
return group_remove(uname, groups.wheel)
|
||||
}
|
||||
|
||||
function group_users_add(new_user: User): GroupSearch {
|
||||
return group_add(new_user, groups.users)
|
||||
}
|
||||
|
||||
function group_users_remove(uname: string): GroupRemoveStatus {
|
||||
return group_remove(uname, groups.users)
|
||||
}
|
||||
|
||||
export default groups
|
||||
export {
|
||||
group_wheel_remove,
|
||||
group_users_remove,
|
||||
groups_find_user,
|
||||
group_wheel_add,
|
||||
group_users_add,
|
||||
group_user_move,
|
||||
type SysGroupsNames,
|
||||
GroupRemoveStatus,
|
||||
GroupSearch,
|
||||
SysGroups,
|
||||
Group,
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
import { type Entry } from "./main"
|
||||
import wrap, { WrapResult } from "./wrap"
|
||||
|
||||
function wrap_bsearch<T extends Entry>(index: number, result: T): WrapResult<T, number> {
|
||||
return wrap(result, index)
|
||||
}
|
||||
|
||||
export default function directory_search<T extends Entry>(dir_files: T[], file_name: string): WrapResult<T, number> | undefined {
|
||||
let start = 0
|
||||
let end = dir_files.length-1
|
||||
while (start<=end) {
|
||||
const median = (start+end)>>1
|
||||
const median_name = dir_files[median].name.__inner()
|
||||
|
||||
if (median_name === file_name) {
|
||||
return wrap_bsearch(median, dir_files[median])
|
||||
} else if (median_name<file_name) {
|
||||
start = median+1
|
||||
} else {
|
||||
end = median-1
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
@ -1,60 +0,0 @@
|
||||
import { wrap_entry, type WrapResultEntry } from "./wrap"
|
||||
import { ReadStatus } from "./enum/status"
|
||||
|
||||
import rfwfs, { type DirectoryAny, type EntryCollection, type DirectoryAnyDepth } from "./main"
|
||||
import fs from "../fs"
|
||||
|
||||
type Path = string[]
|
||||
|
||||
interface Home {
|
||||
path: () => Path,
|
||||
dir: () => DirectoryAny | undefined,
|
||||
}
|
||||
interface Librfwfs {
|
||||
home: Home,
|
||||
traverse_to: (path: Path) => WrapResultEntry<DirectoryAny, ReadStatus>
|
||||
pwd_entry: <T extends EntryCollection<T>>(working_dir: T) => Path | undefined
|
||||
}
|
||||
|
||||
let username: string = "user"
|
||||
|
||||
const librfwfs = {} as Librfwfs
|
||||
|
||||
librfwfs.traverse_to = function(path) {
|
||||
let traverse = fs
|
||||
|
||||
for (const path_name of path) {
|
||||
const find = traverse.inner.find(path_name)
|
||||
|
||||
if (find.status === ReadStatus.Ok) {
|
||||
if (find.result && rfwfs.is_dir(find.result)) {
|
||||
traverse = find.result as DirectoryAnyDepth
|
||||
} else {
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
} else {
|
||||
return wrap_entry(find.status)
|
||||
}
|
||||
}
|
||||
return wrap_entry(ReadStatus.Ok, traverse)
|
||||
}
|
||||
|
||||
librfwfs.pwd_entry = function(working_dir) {
|
||||
|
||||
}
|
||||
|
||||
librfwfs.home = {} as Home
|
||||
|
||||
librfwfs.home.path = function() {
|
||||
return ["home", username]
|
||||
}
|
||||
|
||||
librfwfs.home.dir = function() {
|
||||
const traverse = librfwfs.traverse_to(this.path())
|
||||
return traverse.status === ReadStatus.Ok ? traverse.result : undefined
|
||||
}
|
||||
|
||||
export default librfwfs
|
||||
export {
|
||||
username
|
||||
}
|
||||
@ -1,395 +0,0 @@
|
||||
import wrap, { type WrapResult, ConstEnum, Option } from "./wrap"
|
||||
import { SysGroups } from "./groups"
|
||||
|
||||
import directory_search from "./index"
|
||||
import User, { LibUser } from "./users"
|
||||
|
||||
const enum EntryType {
|
||||
Root,
|
||||
File,
|
||||
Directory,
|
||||
Binary,
|
||||
SymLink,
|
||||
}
|
||||
const enum PushStatus {
|
||||
Ok,
|
||||
Duplicate,
|
||||
Denied,
|
||||
}
|
||||
const enum ReadStatus {
|
||||
Ok,
|
||||
NotFound,
|
||||
NotInGroup,
|
||||
Denied,
|
||||
}
|
||||
const enum ModifyStatus {
|
||||
Ok,
|
||||
NotInGroup,
|
||||
Denied,
|
||||
}
|
||||
const enum ModifyAccessType {
|
||||
Read,
|
||||
Write,
|
||||
}
|
||||
|
||||
const enum ROOT_ID {
|
||||
TRUNK = "/",
|
||||
NAME = "root",
|
||||
UID = 0,
|
||||
}
|
||||
const enum PERMISSION_FLAGS {
|
||||
NONE = -1,
|
||||
R = 1 << 0,
|
||||
W = 1 << 1,
|
||||
X = 1 << 2,
|
||||
RWX = PERMISSION_FLAGS.R | PERMISSION_FLAGS.W | PERMISSION_FLAGS.X
|
||||
}
|
||||
|
||||
interface Permissions<W = Gate<PERMISSION_FLAGS>, U = Gate<PERMISSION_FLAGS>> {
|
||||
wheel: W,
|
||||
users: U,
|
||||
}
|
||||
type GroupPermissionsRoot = Permissions<Gate<PERMISSION_FLAGS>, Gate<PERMISSION_FLAGS.NONE>>
|
||||
|
||||
interface Metadata {
|
||||
[index: string]: string
|
||||
}
|
||||
|
||||
interface Entry<
|
||||
T extends EntryType = EntryType,
|
||||
P extends Permissions = Permissions,
|
||||
N = Gate<string>
|
||||
> {
|
||||
readonly type: T,
|
||||
permissions: P,
|
||||
timestamp: Gate<number>,
|
||||
metadata: Gate<Metadata>,
|
||||
group: Gate<SysGroups>,
|
||||
owner: Gate<User>,
|
||||
name: N,
|
||||
}
|
||||
|
||||
type Directory<T extends Entry> = DirectoryContainer<RfwfsDirectory<T>>
|
||||
|
||||
interface DirectoryContainer<T> extends Entry {
|
||||
files: Gate<Entry[]>,
|
||||
parent: Gate<T> | null,
|
||||
}
|
||||
|
||||
interface Root extends Entry<EntryType.Root, GroupPermissionsRoot, ROOT_ID.TRUNK> {
|
||||
parent: null,
|
||||
files: Gate<Entry[]>,
|
||||
}
|
||||
|
||||
interface DirectoryInRoot extends Entry<EntryType.Root, Permissions {
|
||||
|
||||
}
|
||||
|
||||
interface DirectoryInRootProperties {
|
||||
permissions: Permissions<PERMISSION_FLAGS, PERMISSION_FLAGS.NONE>,
|
||||
timestamp: number,
|
||||
metadata: Metadata,
|
||||
name: string,
|
||||
}
|
||||
|
||||
/** Other directory types that can be treated as a single arbitrary directory.
|
||||
|
||||
Do not cast.
|
||||
*/
|
||||
type DirectoryAssociates<T extends Entry> = Directory<T> | DirectoryInRoot | Root
|
||||
/** Other entry types that can be treated as a single arbitrary entry.
|
||||
|
||||
Do not cast.
|
||||
*/
|
||||
type EntryAssociates = Entry | Root
|
||||
|
||||
type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
|
||||
type WrapResultNone<T> = WrapResult<Option.None, T>
|
||||
type WrapEntryRead<V> = WrapResult<V | undefined, ModifyStatus>
|
||||
|
||||
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(Option.None, status)
|
||||
}
|
||||
|
||||
function wrap_entry_read<V>(status: ModifyStatus, result?: V): WrapEntryRead<V> {
|
||||
return wrap(result, status)
|
||||
}
|
||||
|
||||
function fs_dir_sort<T extends Entry>(dir: DirectoryAssociates<T>) {
|
||||
dir.files.__inner().sort((a,z) => a.name.__inner().localeCompare(z.name.__inner()))
|
||||
}
|
||||
|
||||
function fs_dir_clone<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
|
||||
const clone_find = directory_search(dir.files.__inner(), file_name)
|
||||
if (clone_find) {
|
||||
return wrap_entry(ReadStatus.Ok, { ...clone_find.result as T })
|
||||
}
|
||||
return wrap_entry(ReadStatus.NotFound)
|
||||
}
|
||||
|
||||
function fs_dir_find<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
|
||||
const file_search = directory_search(dir.files.__inner(), file_name)
|
||||
if (file_search) {
|
||||
return wrap_entry(ReadStatus.Ok, file_search.result as T)
|
||||
}
|
||||
return wrap_entry(ReadStatus.NotFound)
|
||||
}
|
||||
|
||||
function fs_dir_push<T extends Entry>(dir: DirectoryAssociates<T>, entry: Entry) {
|
||||
const no_duplicates = directory_search(dir.files.__inner(), entry.name.__inner())
|
||||
if (!no_duplicates) {
|
||||
dir.files.__inner().push(entry)
|
||||
fs_dir_sort(dir)
|
||||
return wrap_none(PushStatus.Ok)
|
||||
}
|
||||
return wrap_none(PushStatus.Duplicate)
|
||||
}
|
||||
|
||||
function fs_dir_pop<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
|
||||
const pop_find = directory_search(dir.files.__inner(), file_name)
|
||||
if (pop_find) {
|
||||
dir.files.__inner().splice(pop_find.status, 1)
|
||||
return wrap_entry(ReadStatus.Ok, pop_find.result as T)
|
||||
}
|
||||
return wrap_entry(ReadStatus.NotFound)
|
||||
}
|
||||
|
||||
function user_group_perms(entry: EntryAssociates): PERMISSION_FLAGS | undefined {
|
||||
const user = LibUser.current_sys_user
|
||||
const current_user_group = user.group()
|
||||
|
||||
if (user.is_root() || current_user_group.type() === entry.group.__inner()) {
|
||||
return entry.permissions[current_user_group.type_as_name()].__inner()
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
function user_group_read_write<T extends Entry>(entry: DirectoryAssociates<T>): ModifyStatus {
|
||||
if (LibUser.current_sys_user.is_root()) {
|
||||
return ModifyStatus.Ok
|
||||
}
|
||||
const group_perms = user_group_perms(entry)
|
||||
if (group_perms) {
|
||||
return LibRfwfs.read_write_access(group_perms) ? ModifyStatus.Ok : ModifyStatus.Denied
|
||||
}
|
||||
return ModifyStatus.NotInGroup
|
||||
}
|
||||
|
||||
class Gate<V> {
|
||||
private inner: V;
|
||||
protected entry: EntryAssociates;
|
||||
|
||||
constructor(entry: EntryAssociates, value: V) {
|
||||
this.inner = value
|
||||
this.entry = entry
|
||||
}
|
||||
|
||||
private access_read_write(accessType: ModifyAccessType): ModifyStatus {
|
||||
const group_perms = user_group_perms(this.entry)
|
||||
if (group_perms) {
|
||||
switch (accessType) {
|
||||
case ModifyAccessType.Read:
|
||||
return LibRfwfs.read_access(group_perms) ? ModifyStatus.Ok : ModifyStatus.Denied
|
||||
case ModifyAccessType.Write:
|
||||
return LibRfwfs.write_access(group_perms) ? ModifyStatus.Ok : ModifyStatus.Denied
|
||||
}
|
||||
}
|
||||
return ModifyStatus.NotInGroup
|
||||
}
|
||||
|
||||
public __inner(): V {
|
||||
return this.inner
|
||||
}
|
||||
|
||||
public read(): WrapEntryRead<V> {
|
||||
switch (this.access_read_write(ModifyAccessType.Read)) {
|
||||
case ModifyStatus.Ok:
|
||||
return wrap_entry_read(ModifyStatus.Ok, this.inner)
|
||||
case ModifyStatus.NotInGroup:
|
||||
return wrap_entry_read(ModifyStatus.NotInGroup)
|
||||
case ModifyStatus.Denied:
|
||||
return wrap_entry_read(ModifyStatus.Denied)
|
||||
}
|
||||
}
|
||||
|
||||
public write<T extends V>(new_value: T): ModifyStatus {
|
||||
switch (this.access_read_write(ModifyAccessType.Read)) {
|
||||
case ModifyStatus.Ok:
|
||||
this.inner = new_value
|
||||
return ModifyStatus.Ok
|
||||
case ModifyStatus.NotInGroup:
|
||||
return ModifyStatus.NotInGroup
|
||||
case ModifyStatus.Denied:
|
||||
return ModifyStatus.Denied
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class RfwfsDirectory<T extends Entry> {
|
||||
public dir: DirectoryAssociates<T>;
|
||||
|
||||
constructor(dir: DirectoryAssociates<T>) {
|
||||
this.dir = dir
|
||||
}
|
||||
|
||||
public sort() {
|
||||
fs_dir_sort(this.dir)
|
||||
}
|
||||
|
||||
public clone(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.dir)) {
|
||||
return fs_dir_clone(this.dir, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public find(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.dir)) {
|
||||
return fs_dir_find(this.dir, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public push<E extends Entry>(entry: E): WrapResultNone<PushStatus> {
|
||||
if (user_group_read_write(this.dir)) {
|
||||
return fs_dir_push(this.dir, entry)
|
||||
}
|
||||
return wrap_none(PushStatus.Denied)
|
||||
}
|
||||
|
||||
public pop(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.dir)) {
|
||||
fs_dir_pop(this.dir, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public push_bulk_unsafe(dirs: T[]) {
|
||||
dirs.forEach(dir => this.dir.files.__inner().push(dir))
|
||||
this.sort()
|
||||
}
|
||||
|
||||
public push_unsafe(dir: T) {
|
||||
this.dir.files.__inner().push(dir)
|
||||
this.sort()
|
||||
}
|
||||
}
|
||||
|
||||
class LibRfwfs {
|
||||
public static is_root<T extends Entry>(entry: T): boolean {
|
||||
return entry.type === EntryType.Root
|
||||
}
|
||||
public static is_dir<T extends Entry>(entry: T): boolean {
|
||||
return entry.type === EntryType.Directory
|
||||
}
|
||||
public static is_file<T extends Entry>(entry: T): boolean {
|
||||
return entry.type === EntryType.File
|
||||
}
|
||||
public static is_binary<T extends Entry>(entry: T): boolean {
|
||||
return entry.type === EntryType.Binary
|
||||
}
|
||||
public static is_symlink<T extends Entry>(entry: T): boolean {
|
||||
return entry.type === EntryType.SymLink
|
||||
}
|
||||
|
||||
public static read_access(permissions: PERMISSION_FLAGS): boolean {
|
||||
return (permissions & PERMISSION_FLAGS.R) !== 0
|
||||
}
|
||||
public static write_access(permissions: PERMISSION_FLAGS): boolean {
|
||||
return (permissions & PERMISSION_FLAGS.W) !== 0
|
||||
}
|
||||
public static execute_access(permissions: PERMISSION_FLAGS): boolean {
|
||||
return (permissions & PERMISSION_FLAGS.X) !== 0
|
||||
}
|
||||
public static read_write_access(permissions: PERMISSION_FLAGS): boolean {
|
||||
return LibRfwfs.read_access(permissions) && LibRfwfs.write_access(permissions)
|
||||
}
|
||||
|
||||
public static directory_in_root(properties: DirectoryInRootProperties): RfwfsDirectory<DirectoryInRoot> {
|
||||
const dir_o = { type: EntryType.Directory } as DirectoryInRoot
|
||||
dir_o.permissions = {
|
||||
wheel: new Gate(dir_o, properties.permissions.wheel),
|
||||
users: new Gate(dir_o, properties.permissions.users),
|
||||
}
|
||||
dir_o.metadata = new Gate(dir_o, properties.metadata)
|
||||
dir_o.timestamp = new Gate(dir_o, properties.timestamp)
|
||||
dir_o.files = new Gate(dir_o, [])
|
||||
dir_o.name = new Gate(dir_o, properties.name)
|
||||
dir_o.parent = null
|
||||
return new RfwfsDirectory(dir_o)
|
||||
}
|
||||
}
|
||||
|
||||
class Rfwfs extends LibRfwfs {
|
||||
public root: Root;
|
||||
|
||||
constructor() {
|
||||
super()
|
||||
this.root = { type: EntryType.Root } as Root
|
||||
this.root.permissions = {
|
||||
wheel: new Gate(this.root, PERMISSION_FLAGS.RWX),
|
||||
users: new Gate(this.root, PERMISSION_FLAGS.NONE)
|
||||
}
|
||||
this.root.timestamp = new Gate(this.root, (Date.now()/1000) | 0)
|
||||
this.root.parent = null
|
||||
this.root.files = new Gate(this.root, [])
|
||||
this.root.name = ROOT_ID.TRUNK
|
||||
}
|
||||
|
||||
public sort() {
|
||||
fs_dir_sort(this.root)
|
||||
}
|
||||
|
||||
public clone(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.root)) {
|
||||
return fs_dir_clone(this.root, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public find(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.root)) {
|
||||
return fs_dir_find(this.root, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public push<T extends Entry>(entry: T): WrapResultNone<PushStatus> {
|
||||
if (user_group_read_write(this.root)) {
|
||||
return fs_dir_push(this.root, entry)
|
||||
}
|
||||
return wrap_none(PushStatus.Denied)
|
||||
}
|
||||
|
||||
public pop(file_name: string): WrapResultEntry<Entry, ReadStatus> {
|
||||
if (user_group_read_write(this.root)) {
|
||||
fs_dir_pop(this.root, file_name)
|
||||
}
|
||||
return wrap_entry(ReadStatus.Denied)
|
||||
}
|
||||
|
||||
public push_bulk_unsafe(dirs: DirectoryInRoot[]) {
|
||||
dirs.forEach(dir => this.root.files.__inner().push(dir))
|
||||
this.sort()
|
||||
}
|
||||
|
||||
public push_unsafe(dir: DirectoryInRoot) {
|
||||
this.root.files.__inner().push(dir)
|
||||
this.sort()
|
||||
}
|
||||
}
|
||||
|
||||
export default Rfwfs
|
||||
export {
|
||||
type DirectoryInRoot,
|
||||
type RfwfsDirectory,
|
||||
type Directory,
|
||||
type Entry,
|
||||
PERMISSION_FLAGS,
|
||||
EntryType,
|
||||
ROOT_ID,
|
||||
}
|
||||
@ -1,182 +0,0 @@
|
||||
import { ROOT_ID } from "./main";
|
||||
|
||||
import Crypto, { type SHA256 } from "../crypto/generate";
|
||||
import groups, { groups_find_user, GroupSearch, SysGroups, Group } from "./groups";
|
||||
|
||||
const enum UserSet {
|
||||
Ok,
|
||||
AlreadyLoggedIn,
|
||||
UserDoesNotExist,
|
||||
}
|
||||
const enum PasswordCheckStatus {
|
||||
Ok,
|
||||
MinBound,
|
||||
MaxBound,
|
||||
}
|
||||
const enum PasswordSetStatus {
|
||||
Ok,
|
||||
RootRequiresPassword,
|
||||
MinBound,
|
||||
MaxBound,
|
||||
Incorrect,
|
||||
}
|
||||
const enum SetUnameStatus {
|
||||
Ok,
|
||||
CantChangeRootName,
|
||||
NotFound,
|
||||
WheelResult,
|
||||
UsersResult,
|
||||
}
|
||||
|
||||
const enum PASS_BOUNDS {
|
||||
MIN = 4,
|
||||
MAX = 1 << 12, //64 ^ 2
|
||||
}
|
||||
|
||||
let uid_count: number = 0
|
||||
|
||||
class LibUser {
|
||||
public static current_sys_user: User;
|
||||
|
||||
public static get_sys_user(): User {
|
||||
return groups.together().find(user => user.is_logged_in()) as User
|
||||
}
|
||||
|
||||
public static set_sys_user(uname: string): UserSet {
|
||||
const found_user = groups_find_user(uname)
|
||||
const result_user_i = found_user.result
|
||||
if (!result_user_i) { return UserSet.UserDoesNotExist }
|
||||
if (result_user_i[0].is_logged_in()) { return UserSet.AlreadyLoggedIn }
|
||||
|
||||
LibUser.current_sys_user = result_user_i[0]
|
||||
return UserSet.Ok
|
||||
}
|
||||
|
||||
public static in_password_bounds(password: string): PasswordCheckStatus {
|
||||
//Math.min(Math.max(PASS_BOUNDS.MIN, password.length), PASS_BOUNDS.MAX) < PASS_BOUNDS.MAX
|
||||
if (password.length > PASS_BOUNDS.MIN) {
|
||||
if (password.length < PASS_BOUNDS.MAX) {
|
||||
return PasswordCheckStatus.Ok
|
||||
}
|
||||
return PasswordCheckStatus.MaxBound
|
||||
}
|
||||
return PasswordCheckStatus.MinBound
|
||||
}
|
||||
}
|
||||
|
||||
class User {
|
||||
private inner_password?: SHA256;
|
||||
private inner_group: Group;
|
||||
private inner_name: string;
|
||||
private inner_uid: number;
|
||||
private current: boolean;
|
||||
|
||||
constructor(name: string, group: Group, password?: SHA256) {
|
||||
const root_creation = name === ROOT_ID.NAME
|
||||
if (root_creation) {
|
||||
this.inner_uid = 0
|
||||
this.inner_group = group
|
||||
} else {
|
||||
uid_count += 1
|
||||
this.inner_uid = uid_count
|
||||
this.inner_group = group
|
||||
}
|
||||
|
||||
this.inner_name = name
|
||||
this.current = root_creation
|
||||
this.inner_password = password
|
||||
}
|
||||
|
||||
private set_as_current(): boolean {
|
||||
LibUser.get_sys_user().current = false
|
||||
LibUser.current_sys_user = this
|
||||
this.current = true
|
||||
return this.current
|
||||
}
|
||||
|
||||
public is_logged_in(): boolean {
|
||||
return this.current
|
||||
}
|
||||
public in_wheel(): boolean {
|
||||
return this.inner_group.type() === SysGroups.Wheel
|
||||
}
|
||||
public password(): SHA256 | undefined {
|
||||
return this.inner_password
|
||||
}
|
||||
public is_root(): boolean {
|
||||
return this.inner_name === ROOT_ID.NAME && this.inner_uid === ROOT_ID.UID
|
||||
}
|
||||
public group(): Group {
|
||||
return this.inner_group
|
||||
}
|
||||
public uname(): string {
|
||||
return this.inner_name
|
||||
}
|
||||
public uid(): number {
|
||||
return this.inner_uid
|
||||
}
|
||||
|
||||
public async check_password(password?: string): Promise<boolean> {
|
||||
if (!(password && this.inner_password) || (await new Crypto(password).sha256_hash()).secret === this.inner_password.secret) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
public async login(password?: string): Promise<boolean> {
|
||||
if (!this.inner_password || (password && await this.check_password(password))) {
|
||||
return this.set_as_current()
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
public set_uname(new_uname: string): SetUnameStatus {
|
||||
if (this.is_root()) { return SetUnameStatus.CantChangeRootName }
|
||||
|
||||
const search = groups_find_user(new_uname)
|
||||
switch (search.status) {
|
||||
case GroupSearch.NotFound:
|
||||
this.inner_name = new_uname
|
||||
break
|
||||
case GroupSearch.UsersResult:
|
||||
return SetUnameStatus.UsersResult
|
||||
case GroupSearch.WheelResult:
|
||||
return SetUnameStatus.WheelResult
|
||||
}
|
||||
return SetUnameStatus.Ok
|
||||
}
|
||||
|
||||
public async set_password(current_password: string, new_password?: string): Promise<PasswordSetStatus> {
|
||||
if (await this.check_password(current_password)) {
|
||||
if (new_password) {
|
||||
switch (LibUser.in_password_bounds(new_password)) {
|
||||
case PasswordCheckStatus.Ok:
|
||||
this.inner_password = await new Crypto(new_password).sha256_hash()
|
||||
break
|
||||
case PasswordCheckStatus.MinBound:
|
||||
return PasswordSetStatus.MinBound
|
||||
case PasswordCheckStatus.MaxBound:
|
||||
return PasswordSetStatus.MaxBound
|
||||
}
|
||||
} else {
|
||||
if (this.is_root()) { return PasswordSetStatus.RootRequiresPassword }
|
||||
//This user has no password
|
||||
this.inner_password = undefined
|
||||
}
|
||||
return PasswordSetStatus.Ok
|
||||
}
|
||||
return PasswordSetStatus.Incorrect
|
||||
}
|
||||
}
|
||||
|
||||
groups.wheel.add_user(
|
||||
new User(ROOT_ID.NAME, groups.wheel, { secret: "90a956efae97cca5ec584977d96a236aa76b0a07def9fcafab87fd221a1d2cfe" })
|
||||
)
|
||||
groups.users.add_user(
|
||||
new User("user", groups.users)
|
||||
)
|
||||
|
||||
export default User
|
||||
export {
|
||||
LibUser
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
const enum Option {
|
||||
None,
|
||||
Some,
|
||||
}
|
||||
|
||||
type ConstEnum = number
|
||||
|
||||
interface WrapResult<T, U> {
|
||||
/** The resulting value if `U` is a success status */
|
||||
readonly result: T,
|
||||
/** Represents some arbitrary extra value, usually a status */
|
||||
readonly status: U,
|
||||
}
|
||||
|
||||
function wrap<T, U>(result: T, some: U): WrapResult<T, U> {
|
||||
return { result: result, status: some }
|
||||
}
|
||||
|
||||
export default wrap
|
||||
export {
|
||||
type WrapResult,
|
||||
type ConstEnum,
|
||||
Option,
|
||||
}
|
||||
@ -7,23 +7,20 @@ const enum Colors {
|
||||
cyan = "cyan",
|
||||
bold = "bold"
|
||||
}
|
||||
function newcolor(inner: string, color?: Colors, bold?: boolean) {
|
||||
function newcolor(inner: string, color?: Colors) {
|
||||
const span = create("span", color)
|
||||
span.innerText = inner
|
||||
if (bold) {
|
||||
span.className = color ? color+" bold" : "bold"
|
||||
}
|
||||
return span
|
||||
}
|
||||
|
||||
const red = (s: string, bold?: boolean) => newcolor(s, Colors.red, bold)
|
||||
const green = (s: string, bold?: boolean) => newcolor(s, Colors.green, bold)
|
||||
const blue = (s: string, bold?: boolean) => newcolor(s, Colors.blue, bold)
|
||||
const cyan = (s: string, bold?: boolean) => newcolor(s, Colors.cyan, bold)
|
||||
const red = (s: string) => newcolor(s, Colors.red )
|
||||
const green = (s: string) => newcolor(s, Colors.green)
|
||||
const blue = (s: string) => newcolor(s, Colors.blue)
|
||||
const cyan = (s: string) => newcolor(s, Colors.cyan)
|
||||
const bold = (s: string) => newcolor(s, Colors.bold)
|
||||
|
||||
export default function rgb(s: string, Ru8: number, Gu8: number, Bu8: number, bold?: boolean) {
|
||||
const rgb_span = newcolor(s, undefined, bold)
|
||||
export default function rgb(s: string, Ru8: number, Gu8: number, Bu8: number) {
|
||||
const rgb_span = newcolor(s)
|
||||
rgb_span.style.color = `rgb(${Ru8},${Gu8},${Bu8})`
|
||||
return rgb_span
|
||||
}
|
||||
|
||||
@ -1,16 +1,13 @@
|
||||
import { ReadStatus } from "../../../rfwfs/enum"
|
||||
import { set_working_dir, SetDirStatus } from "../../fs/fn"
|
||||
import type { Args, Term } from "../list"
|
||||
|
||||
import lib from "../../../rfwfs/library"
|
||||
import stdout from "../../../elements/stdout"
|
||||
|
||||
export default function cd(term: Term, args: Args): boolean {
|
||||
const new_dir_status = lib.traverse_to(args)
|
||||
const new_dir_status = set_working_dir(args[1])
|
||||
|
||||
if (new_dir_status === SetDirStatus.NotADirectory) {
|
||||
term.appendChild(stdout(`cd: "${args[1]}" is not a directory`))
|
||||
// return <p>{"cd: \""}{bold(args[1])}{"\" is not a directory"}</p>
|
||||
} else if (new_dir_status === SetDirStatus.NotFound) {
|
||||
term.appendChild(stdout(`cd: The directory "${args[1]}" does not exist`))
|
||||
// return <p>{"cd: The directory \""}{bold(args[1])}{"\" does not exist"}</p>
|
||||
}
|
||||
return true
|
||||
}
|
||||
@ -7,7 +7,7 @@ import history from "../../history";
|
||||
const history_command = new SubCommand("Show and manipulate command history")
|
||||
|
||||
history_command.add("show", "Show the history", function(term: Term, _args: Args) {
|
||||
history.file.inner.forEach((entry, ind) => term.appendChild(stdout(`${ind+1} ${entry}`)))
|
||||
history.file.inner.forEach((entry, ind) => term.appendChild(stdout(`${ind} ${entry}`)))
|
||||
})
|
||||
|
||||
history_command.add("clear", "Delete the entire command history", function(term: Term, _args: Args) {
|
||||
|
||||
@ -1,30 +1,11 @@
|
||||
import type { Args, Term } from "../list";
|
||||
import { blue } from "../../color";
|
||||
import { get_working_dir_entries } from "../../../rfwfs/library";
|
||||
import { EntryType, FsEntry } from "../../../rfwfs/core";
|
||||
|
||||
import stdout, { stdout_horizontal_elements } from "../../../elements/stdout";
|
||||
import create from "../../../elements/create";
|
||||
|
||||
const element_collection = <T extends HTMLElement>(): T[] => []
|
||||
|
||||
function show_directory(entry: FsEntry) {
|
||||
const p = create("p")
|
||||
p.append(blue(entry.name, true), "/")
|
||||
return p
|
||||
}
|
||||
|
||||
export default function ls(term: Term, args: Args): boolean {
|
||||
const ls_elements = element_collection()
|
||||
if (args[1] === undefined) {
|
||||
get_working_dir_entries().forEach(entry => {
|
||||
if (entry.type === EntryType.Directory) {
|
||||
ls_elements.push(show_directory(entry))
|
||||
} else if (entry.type === EntryType.File) {
|
||||
ls_elements.push(stdout(entry.name))
|
||||
}
|
||||
})
|
||||
}
|
||||
term.appendChild(stdout_horizontal_elements(ls_elements))
|
||||
// if (args[1] === undefined) {
|
||||
// for (const dir_name in working_dir) {
|
||||
|
||||
// }
|
||||
// return <p>{`${working_dir}`}</p>
|
||||
// }
|
||||
return true
|
||||
}
|
||||
@ -1,4 +1,4 @@
|
||||
import { get_working_dir_name_full } from "../../../rfwfs/library";
|
||||
import { get_working_dir_name_full } from "../../fs/fn";
|
||||
import type { Args, Term } from "../list";
|
||||
|
||||
import stdout from "../../../elements/stdout";
|
||||
|
||||
75
src/rt/shell/fs/fn.ts
Normal file
75
src/rt/shell/fs/fn.ts
Normal file
@ -0,0 +1,75 @@
|
||||
import { EntryType, fs, type FsEntrySignature } from "./fs"
|
||||
|
||||
let working_dir = ["/", "home", "user"]
|
||||
|
||||
function get_working_dir_name() {
|
||||
return working_dir[working_dir.length-1]
|
||||
}
|
||||
|
||||
function get_working_dir_name_full(): string {
|
||||
const w_dir_clone = [...working_dir]
|
||||
const root = w_dir_clone.shift()
|
||||
if (root) {
|
||||
return root+w_dir_clone.join("/")
|
||||
}
|
||||
return "shift-error"
|
||||
}
|
||||
|
||||
const enum SetDirStatus {
|
||||
Valid,
|
||||
NotFound,
|
||||
NotADirectory
|
||||
}
|
||||
interface FsIterEntry {
|
||||
readonly entry: FsEntrySignature | null,
|
||||
readonly status: SetDirStatus
|
||||
}
|
||||
function iter_fs_to_goal(w_dir_clone: string[]): FsIterEntry {
|
||||
let next_iter = fs[0]
|
||||
|
||||
for (const w_dir of w_dir_clone) {
|
||||
if (w_dir === "/") { continue }
|
||||
if (next_iter && next_iter.inner) {
|
||||
const found = next_iter.inner.find(entry => entry.name === w_dir)
|
||||
|
||||
if (!found) {
|
||||
return { entry: null, status: SetDirStatus.NotFound }
|
||||
}
|
||||
if (found.type !== EntryType.Directory) {
|
||||
return { entry: null, status: SetDirStatus.NotADirectory }
|
||||
}
|
||||
if (found.name === w_dir_clone[w_dir_clone.length-1]) {
|
||||
return { entry: next_iter, status: SetDirStatus.Valid }
|
||||
} else {
|
||||
next_iter = found.inner as FsEntrySignature
|
||||
}
|
||||
}
|
||||
}
|
||||
return { entry: null, status: SetDirStatus.NotFound }
|
||||
}
|
||||
|
||||
function set_working_dir(name: string): SetDirStatus {
|
||||
if (name === ".") { return SetDirStatus.Valid }
|
||||
|
||||
const w_dir_clone = [...working_dir]
|
||||
if (name === "..") { w_dir_clone.pop() } else { w_dir_clone.push(name) }
|
||||
|
||||
const iter_status = iter_fs_to_goal(w_dir_clone)
|
||||
if (iter_status.status === SetDirStatus.Valid) {
|
||||
working_dir = w_dir_clone
|
||||
}
|
||||
return iter_status.status
|
||||
}
|
||||
|
||||
function working_dir_entries() {
|
||||
const w_dir_clone = [...working_dir]
|
||||
const iter_status = iter_fs_to_goal(w_dir_clone)
|
||||
|
||||
}
|
||||
|
||||
export {
|
||||
get_working_dir_name,
|
||||
get_working_dir_name_full,
|
||||
set_working_dir,
|
||||
SetDirStatus
|
||||
}
|
||||
51
src/rt/shell/fs/fs.ts
Normal file
51
src/rt/shell/fs/fs.ts
Normal file
@ -0,0 +1,51 @@
|
||||
const enum EntryType {
|
||||
Directory,
|
||||
File
|
||||
}
|
||||
const enum Permissions {
|
||||
r,
|
||||
w,
|
||||
rw
|
||||
}
|
||||
|
||||
type FsEntrySignature = Entry<Entry<{}>[]> //I did this!
|
||||
|
||||
const user = [
|
||||
Entry("about_me.txt", "about me inside", Permissions.rw),
|
||||
Entry("services.txt", "services inside", Permissions.rw),
|
||||
Entry("hi", [], Permissions.rw)
|
||||
]
|
||||
const home = [
|
||||
Entry("user", user, Permissions.rw)
|
||||
]
|
||||
const root = [
|
||||
Entry("home", home, Permissions.r),
|
||||
Entry("bin", {}, Permissions.r),
|
||||
]
|
||||
const fs = [
|
||||
Entry("/", root, Permissions.r)
|
||||
]
|
||||
|
||||
type File = string
|
||||
interface Entry<T = File> {
|
||||
readonly inner?: T,
|
||||
readonly name: string,
|
||||
readonly type: EntryType,
|
||||
readonly permissions: Permissions
|
||||
}
|
||||
function Entry<T = File>(name: string, inner: T, permissions: Permissions): Entry<T> {
|
||||
return {
|
||||
type: typeof inner == "object" ? EntryType.Directory : EntryType.File,
|
||||
inner: inner,
|
||||
name: name,
|
||||
permissions: permissions
|
||||
}
|
||||
}
|
||||
|
||||
export {
|
||||
fs,
|
||||
type FsEntrySignature,
|
||||
EntryType,
|
||||
Permissions,
|
||||
Entry
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
import history from "../shell/history"
|
||||
import prompt from "../elements/prompt"
|
||||
import history from "./shell/history"
|
||||
import prompt from "./elements/prompt"
|
||||
import keys from "./keys"
|
||||
|
||||
const term_win_unsafe = document.querySelector("main")
|
||||
@ -1,5 +1,3 @@
|
||||
@use "../variables.scss";
|
||||
|
||||
@mixin text-styles {
|
||||
.red { color: rgb(var(--color-red)) }
|
||||
.green { color: rgb(var(--color-green)) }
|
||||
@ -32,13 +30,17 @@
|
||||
@mixin formatting {
|
||||
@include stdout-layouts;
|
||||
@include term-elements;
|
||||
|
||||
p {
|
||||
@include text-styles;
|
||||
|
||||
p, a, span {
|
||||
font-size: variables.$default-font-size
|
||||
}
|
||||
p {
|
||||
font-size: 1.2rem;
|
||||
margin: 5px;
|
||||
a:hover { text-decoration: underline; }
|
||||
|
||||
span { font-size: inherit; }
|
||||
a {
|
||||
font-size: inherit;
|
||||
&:hover { text-decoration: underline; }
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,3 @@
|
||||
$default-font-size: 1.2rem;
|
||||
|
||||
$header-Y: 30px;
|
||||
$footer-Y: 30px;
|
||||
$component-padding: 20px;
|
||||
|
||||
@ -16,7 +16,6 @@
|
||||
/* Linting */
|
||||
"strict": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true,
|
||||
"noFallthroughCasesInSwitch": true,
|
||||
"noUncheckedSideEffectImports": true,
|
||||
"noImplicitAny": true,
|
||||
|
||||
@ -1,6 +1,10 @@
|
||||
import { defineConfig } from 'vite'
|
||||
import { createHtmlPlugin } from 'vite-plugin-html'
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [
|
||||
createHtmlPlugin({minify: true}),
|
||||
],
|
||||
root: "src",
|
||||
build: {
|
||||
outDir: "../dist"
|
||||
|
||||
Reference in New Issue
Block a user