classicy 0.5.4 → 0.5.5

package/src/SystemFolder/SystemResources/File/ClassicyFileBrowserViewTable.tsx

@@ -1,235 +0,0 @@
-import {capitalizeFirst, iconImageByType} from '@/SystemFolder/SystemResources/File/ClassicyFileBrowserUtils'
-import './ClassicyFileBrowserViewTable.scss'
-import {ClassicyFileSystem} from '@/SystemFolder/SystemResources/File/ClassicyFileSystem'
-import {ClassicyFileSystemEntryMetadata} from '@/SystemFolder/SystemResources/File/ClassicyFileSystemModel'
-import {createColumnHelper, flexRender, getCoreRowModel, getSortedRowModel, useReactTable,} from '@tanstack/react-table'
-import classNames from 'classnames'
-import React, {RefObject, useMemo, useState} from 'react'
-import arrowUpIcon from 'img/ui/menu-dropdown-arrow-up.svg'
-
-type ClassicyFileBrowserViewTableProps = {
-    fs: ClassicyFileSystem
-    path: string
-    appId: string
-    iconSize?: number
-    dirOnClickFunc?: any
-    fileOnClickFunc?: any
-    holderRef?: RefObject<HTMLDivElement | null>
-}
-
-type ColumnSort = {
-    id: string
-    desc: boolean
-}
-type SortingState = ColumnSort[]
-
-export const ClassicyFileBrowserViewTable: React.FC<ClassicyFileBrowserViewTableProps> = ({
-                                                                                              fs,
-                                                                                              path,
-                                                                                              iconSize = 64,
-                                                                                              appId,
-                                                                                              dirOnClickFunc = () => {
-                                                                                              },
-                                                                                              fileOnClickFunc = () => {
-                                                                                              },
-                                                                                          }) => {
-    const [selectedRow, setSelectedRow] = useState<string>()
-    const [sorting, setSorting] = useState<SortingState>([{id: '_name', desc: false}])
-
-    const openFileOrFolder = (properties: ClassicyFileSystemEntryMetadata, path: string, filename: string) => {
-        switch (properties['_type']) {
-            case 'directory': {
-                return dirOnClickFunc(path + ':' + filename)
-            }
-            case 'file': {
-                return fileOnClickFunc(path + ':' + filename)
-            }
-            default: {
-                return () => {
-                }
-            }
-        }
-    }
-
-    const fileList = useMemo<ClassicyFileSystemEntryMetadata[]>(() => {
-        const a: [string, ClassicyFileSystemEntryMetadata][] = Object.entries(
-            fs.filterByType(path, ['file', 'directory'])
-        )
-        const directoryListing = a.map(([d, e]) => {
-            let g = e
-            g['_name'] = d
-            g['_path'] = path + ':' + d
-            return g
-        })
-
-        return Object.entries(directoryListing).map((entry) => {
-            let filteredValues = {} as Record<string, any>
-            const filteredKeyArray: [string, string][] = Object.entries(
-                entry[1]).filter((key) => key[0].startsWith('_')
-            )
-            for (const [key, value] of filteredKeyArray) {
-                filteredValues[key] = value
-            }
-
-            return filteredValues as ClassicyFileSystemEntryMetadata
-        })
-    }, [path, fs])
-
-    const columnHelper = createColumnHelper<ClassicyFileSystemEntryMetadata>()
-
-    const columns = useMemo(
-        () => [
-            columnHelper.accessor((row) => row._name, {
-                id: '_name',
-                cell: (info) => (
-                    <div className={"classicyFileBrowserViewTableRowContainer"}>
-                        <img
-                            src={info.row.original['_icon'] || iconImageByType(info.row.original['_type'])}
-                            width={iconSize}
-                            alt={info.row.original['_path']}
-                            className={"classicyFileBrowserViewTableRowIcon"}
-                        />
-                        <span className={"classicyFileBrowserViewTableRowIconLabel"}>
-                            {info.getValue()}
-                        </span>
-                    </div>
-                ),
-                header: () => <span>Filename</span>,
-                enableResizing: true,
-            }),
-            columnHelper.accessor((row) => row._type, {
-                id: '_type',
-                cell: (info) => <span>{capitalizeFirst(info.getValue())}</span>,
-                header: () => <span>File Type</span>,
-                enableResizing: true,
-            }),
-            columnHelper.accessor((row) => row._size, {
-                id: '_size',
-                cell: (info) =>
-                    <span>{info.getValue() != undefined ? (fs.formatSize(info.getValue() ?? 0)) : ""}</span>,
-                header: () => <span>Size</span>,
-                enableResizing: true,
-            }),
-        ],
-        []
-    )
-
-    const table = useReactTable({
-        data: fileList,
-        columns,
-        getCoreRowModel: getCoreRowModel(),
-        getSortedRowModel: getSortedRowModel(),
-        state: {
-            sorting,
-        },
-        onSortingChange: setSorting,
-        columnResizeMode: 'onChange',
-    })
-
-    return (
-        <div
-            key={appId + '_filebrowser_' + path}
-            className={"classicyFileBrowserViewTableContainer"}
-        >
-            <table style={{}} className={"classicyFileBrowserViewTable"}>
-                <thead className={classNames("classicyFileBrowserViewTableHeader")}>
-                {table.getHeaderGroups().map((headerGroup) => (
-                    <tr
-                        key={headerGroup.id}
-                        className={"classicyFileBrowserViewTableColumnHeaderGroup"}
-                    >
-                        {headerGroup.headers.map((header) => (
-                            <th
-                                key={header.id}
-                                align={'left'}
-                                className={classNames(
-                                    "classicyFileBrowserViewTableColumnHeader",
-                                    header.column.getIsResizing() ? 'isResizing' : '',
-                                    header.id == sorting[0].id
-                                        ? "classicyFileBrowserViewTableColumnHeaderSelected"
-                                        : ''
-                                )}
-                                style={{
-                                    width: header.id === '_icon' ? iconSize : 'auto',
-                                }}
-                                onClick={() => {
-                                    if (
-                                        header.column.getIsSorted() == false ||
-                                        header.column.getIsSorted() == 'desc'
-                                    ) {
-                                        header.column.toggleSorting(false, false)
-                                    } else {
-                                        header.column.toggleSorting(true, false)
-                                    }
-                                }}
-                            >
-                                {!header.isPlaceholder &&
-                                    flexRender(header.column.columnDef.header, header.getContext())}
-                                {header.id == sorting[0].id && (
-                                    <img
-                                        src={`${arrowUpIcon}`}
-                                        alt={'Up Arrow'}
-                                        style={{
-                                            margin: '0 var(--window-padding-size)',
-                                            transform: `rotate(${sorting[0].desc ? '0deg' : '180deg'})`,
-                                            height: "calc(var(--ui-font-size) * 0.5)"
-
-                                        }}
-                                    />
-                                )}
-                                {header.column.getCanResize() && (
-                                    <div
-                                        onMouseDown={header.getResizeHandler()}
-                                        onTouchStart={header.getResizeHandler()}
-                                        className={classNames(
-                                            "resizer",
-                                            header.column.getIsResizing()
-                                                ? "isResizing"
-                                                : ''
-                                        )}
-                                    ></div>
-                                )}
-                            </th>
-                        ))}
-                    </tr>
-                ))}
-                </thead>
-                <tbody className={"classicyFileBrowserViewTableContent"}>
-                {table.getRowModel().rows.map((row) => (
-                    <tr
-                        key={row.id}
-                        className={classNames(
-                            "classicyFileBrowserViewTableRow",
-                            selectedRow === row.id
-                                ? "classicyFileBrowserViewTableRowSelected"
-                                : null
-                        )}
-                        onDoubleClick={() => openFileOrFolder(row.original, path, (row.original._name ?? ""))}
-                        onClick={() => setSelectedRow(row.id)}
-                    >
-                        {row.getVisibleCells().map((cell) => (
-                            <td key={cell.id} style={{width: cell.column.getSize(), margin: 0, padding: 0}}>
-                                {flexRender(cell.column.columnDef.cell, cell.getContext())}
-                            </td>
-                        ))}
-                    </tr>
-                ))}
-                </tbody>
-                <tfoot>
-                {table.getFooterGroups().map((footerGroup) => (
-                    <tr key={footerGroup.id}>
-                        {footerGroup.headers.map((header) => (
-                            <th key={header.id}>
-                                {header.isPlaceholder
-                                    ? null
-                                    : flexRender(header.column.columnDef.footer, header.getContext())}
-                            </th>
-                        ))}
-                    </tr>
-                ))}
-                </tfoot>
-            </table>
-            <div className="h-4"/>
-        </div>
-    )
-}

package/src/SystemFolder/SystemResources/File/ClassicyFileSystem.ts

@@ -1,338 +0,0 @@
-import { sha512 } from 'sha512-crypt-ts'
-import { DefaultFSContent } from '@/SystemFolder/SystemResources/File/DefaultClassicyFileSystem'
-import {
-    ClassicyFileSystemEntry,
-    ClassicyFileSystemEntryFileType,
-    ClassicyFileSystemEntryMetadata,
-} from '@/SystemFolder/SystemResources/File/ClassicyFileSystemModel'
-import directoryIcon from 'img/icons/system/folders/directory.png'
-
-export type ClassicyPathOrFileSystemEntry = string | ClassicyFileSystemEntry
-
-export class ClassicyFileSystem {
-    storageKey: string
-    fs: ClassicyFileSystemEntry
-    separator: string
-
-    constructor(storageKey: string = 'classicyStorage', defaultFS: any = DefaultFSContent, separator: string = ':') {
-        this.storageKey = storageKey
-        this.fs = defaultFS
-
-        const retrieved = localStorage.getItem(this.storageKey)
-        if (typeof window !== 'undefined' && retrieved) {
-            const parsed = JSON.parse(retrieved)
-            if (parsed) {
-                this.fs = parsed
-            }
-        }
-
-        this.separator = separator
-        localStorage.setItem(this.storageKey, this.snapshot())
-    }
-
-    load(data: string) {
-        this.fs = JSON.parse(data) as ClassicyFileSystemEntry
-    }
-
-    snapshot(): string {
-        return JSON.stringify(this.fs, null, 2)
-    }
-
-    pathArray = (path: string) => {
-        return [...path.split(this.separator)].filter((v) => v !== '')
-    }
-
-    resolve(path: string): ClassicyFileSystemEntry {
-        return this.pathArray(path).reduce((prev, curr) => prev?.[curr], this.fs)
-    }
-
-    formatSize(bytes: number, measure: 'bits' | 'bytes' = 'bytes', decimals: number = 2): string {
-        if (!+bytes) {
-            return '0 ' + measure
-        }
-        const sizes =
-            measure === 'bits'
-                ? ['Bits', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb']
-                : ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-
-        const i = Math.floor(Math.log(bytes) / Math.log(1024))
-        bytes = measure === 'bits' ? bytes * 8 : bytes
-
-        return `${parseFloat((bytes / Math.pow(1024, i)).toFixed(Math.max(0, decimals)))} ${sizes[i]}`
-    }
-
-    filterMetadata(content: ClassicyFileSystemEntry, mode: 'only' | 'remove' = 'remove') {
-        let items = {} as ClassicyFileSystemEntry
-
-        Object.entries(content).forEach(([key, value]) => {
-            switch (mode) {
-                case 'only': {
-                    if (key.startsWith('_')) {
-                        items[key] = value
-                    }
-                    break
-                }
-                default: {
-                    if (!key.startsWith('_')) {
-                        items[key] = value
-                    }
-                    break
-                }
-            }
-        })
-        return items
-    }
-
-    filterByType(
-        path: string,
-        byType: string | string[] = ['file', 'directory'],
-        showInvisible: boolean = true
-    ): ClassicyFileSystemEntry {
-        let filteredItems = {} as ClassicyFileSystemEntry
-        if (!this.resolve(path)) return filteredItems
-        Object.entries(this.resolve(path)).forEach(([b, a]) => {
-            if (a['_invisible'] === true && !showInvisible) {
-                return
-            }
-            if (byType.includes(a['_type'])) {
-                filteredItems[b] = a
-            }
-        })
-        return filteredItems
-    }
-
-    statFile(path: string): ClassicyFileSystemEntry {
-        let item = this.resolve(path)
-        item['_size'] = this.size(path)
-        return item
-    }
-
-    size(path: ClassicyPathOrFileSystemEntry): number {
-        if (typeof path === 'string') {
-            const contents = this.readFile(path)
-            if (contents != undefined) {
-                return new Blob(contents.split('')).size
-            }
-        } else if ('_data' in path) {
-            return new Blob((path['_data'] as string).split('')).size
-        }
-
-        return -1
-    }
-
-    hash(path: ClassicyPathOrFileSystemEntry): string | undefined {
-        if (typeof path === 'string') {
-            const contents = this.readFile(path)
-            if (contents == undefined) {
-                return
-            }
-            return sha512.crypt(contents, '')
-        }
-
-        if ('_data' in path) {
-            return sha512.crypt(path['_data'], '')
-        }
-        return
-    }
-
-    readFile(path: ClassicyPathOrFileSystemEntry): string | undefined {
-        if (typeof path === 'string') {
-            let item: ClassicyFileSystemEntry = this.resolve(path)
-            return this.readFile(item)
-        }
-
-        if ('_data' in path) {
-            return path['_data'] as string
-        }
-
-        return
-    }
-
-    writeFile(path: string, data: string, metaData?: ClassicyFileSystemEntryMetadata) {
-        const updateObjProp = (obj: Record<string, any>, value: string, propPath: string) => {
-            const [head, ...rest] = propPath.split(':')
-
-            rest.length ? updateObjProp(obj[head], value, rest.join(':')) : (obj[head] = value)
-        }
-
-        let directoryPath = path.split(':')
-        if (!this.resolve(directoryPath.join(':'))) {
-            this.mkDir(directoryPath.join(':'))
-        }
-
-        return updateObjProp(this.fs, data, path)
-
-        //     let directoryPath = path.split(':')
-        //     const filename = directoryPath.pop()
-        //     if (!this.resolve(directoryPath.join(':'))) {
-        //         this.mkDir(directoryPath.join(':'))
-        //     }
-        //
-        //     let pathArray = []
-        //     let cs: ClassicyFileSystemEntry
-        //     return directoryPath.map((p) => {
-        //         pathArray.push(p)
-        //
-        //         const dir = this.resolve(directoryPath.join(':'))
-        //         cs[p] = dir
-        //         return dir
-        //     })
-        //
-        //     let newDirectoryObject = metaData
-        //         ? metaData
-        //         : {
-        //               _type: 'file',
-        //               _icon: `/img/icons/system/files/file.png`,
-        //           }
-        //
-        //     newDirectoryObject['_data'] = data
-        //
-        //     let current
-        //     let reference = current
-        //     const parts: string[] = this.pathArray(path)
-        //
-        //     for (let i = parts.length - 1; i >= 0; i--) {
-        //         reference = current
-        //         current = i === 0 ? {} : newDirectoryObject
-        //         current[parts[i]] =
-        //             i === parts.length - 1 ? newDirectoryObject : reference
-        //     }
-        //
-        //     this.fs = this.deepMerge(current, this.fs)
-        // }
-    }
-
-    rmDir(path: string) {
-        return this.deletePropertyPath(this.fs, path)
-    }
-
-    mkDir(path: string) {
-        const parts: string[] = this.pathArray(path)
-
-        const newDirectoryObject = () => {
-            return {
-                _type: 'directory',
-                _icon: directoryIcon,
-            } as ClassicyFileSystemEntry
-        }
-
-        let current = {} as ClassicyFileSystemEntry
-        let reference
-
-        for (let i = parts.length - 1; i >= 0; i--) {
-            reference = current
-            current = i === 0 ? {} as ClassicyFileSystemEntry : newDirectoryObject()
-            current[parts[i]] = i === parts.length - 1 ? newDirectoryObject() : reference
-        }
-
-        this.fs = this.deepMerge(current, this.fs)
-    }
-
-    calculateSizeDir(path: ClassicyPathOrFileSystemEntry | string): number {
-        const gatherSizes = (entry: ClassicyFileSystemEntry, field: string, value: string): any[] => {
-            let results: string[] = []
-            for (const key in entry) {
-                if (key === field && entry[key] === value) {
-                    results.push(String(this.size(entry)))
-                } else if (typeof entry[key] === 'object' && entry[key] !== null) {
-                    results = results.concat(gatherSizes(entry[key] as ClassicyFileSystemEntry, field, value))
-                }
-            }
-            return results
-        }
-
-        if (typeof path === 'string') {
-            path = this.resolve(path)
-        }
-
-        return gatherSizes(path, '_type', 'file').reduce((a, c) => a + +c, 0)
-    }
-
-    countVisibleFiles(path: string): number {
-        const visibleFiles: boolean[] = Object.entries(this.filterMetadata(this.resolve(path)))
-            .map(([_, b]) => {
-                return !b['_invisible']
-            })
-            .filter(function (element) {
-                return element || undefined
-            })
-        return visibleFiles.length
-    }
-
-    countInvisibleFilesInDir(path: string): number {
-        const invisibleFiles: boolean[] = Object.entries(this.filterMetadata(this.resolve(path)))
-            .map(([a, b]) => {
-                return b['_invisible']
-            })
-            .filter(function (element) {
-                return element === false
-            })
-        return invisibleFiles.length
-    }
-
-    statDir(path: string): ClassicyFileSystemEntry | undefined {
-        let current: ClassicyFileSystemEntry = this.resolve(path)
-        if (!current) {
-            return
-        }
-        let metaData = this.filterMetadata(current, 'only')
-
-        let name = path.split(this.separator).slice(-1)
-
-        let returnValue: ClassicyFileSystemEntry = {
-            _count: this.countVisibleFiles(path),
-            _countHidden: this.countInvisibleFilesInDir(path),
-            _name: name[0],
-            _path: path,
-            _size: this.calculateSizeDir(current),
-            _type: ClassicyFileSystemEntryFileType.Directory,
-        }
-
-        Object.entries(metaData).forEach(([key, value]) => {
-            returnValue[key] = value
-        })
-
-        return returnValue
-    }
-
-    private deepMerge(source: ClassicyFileSystemEntry, target: ClassicyFileSystemEntry): ClassicyFileSystemEntry {
-        Object.keys(target).forEach((key) => {
-            const sourceKeyIsObject = source[key] instanceof Object
-            const targetKeyIsObject = target[key] instanceof Object
-
-            if (sourceKeyIsObject && targetKeyIsObject) {
-                const sourceKeyIsArray = source[key] instanceof Array
-                const targetKeyIsArray = target[key] instanceof Array
-
-                if (sourceKeyIsArray && targetKeyIsArray) {
-                    source[key] = Array.from(new Set(source[key].concat(target[key])))
-                } else if (!sourceKeyIsArray && !targetKeyIsArray) {
-                    this.deepMerge(source[key], target[key])
-                } else {
-                    source[key] = target[key]
-                }
-            } else {
-                source[key] = target[key]
-            }
-        })
-        return source
-    }
-
-    private deletePropertyPath(fileSystem: ClassicyFileSystemEntry, path: string): ClassicyFileSystemEntry | undefined {
-        const pathToArray = path.split(':')
-
-        for (let i = 0; i < pathToArray.length - 1; i++) {
-            fileSystem = fileSystem[pathToArray[i]]
-            if (typeof fileSystem === 'undefined') {
-                return
-            }
-        }
-
-        const updatedPath = pathToArray.pop()
-        if (updatedPath) {
-            delete fileSystem[updatedPath]
-        }
-
-        return fileSystem
-    }
-}

package/src/SystemFolder/SystemResources/File/ClassicyFileSystemModel.ts

@@ -1,62 +0,0 @@
-import { ReactNode } from 'react'
-
-export enum ClassicyFileSystemEntryFileType {
-    File = 'file',
-    Shortcut = 'shortcut',
-    AppShortcut = 'app_shortcut',
-    Drive = 'drive',
-    Directory = 'directory',
-}
-
-export type ClassicyFileSystemEntryMetadata = {
-    // The type of file
-    _type: ClassicyFileSystemEntryFileType
-    _mimeType?: string
-
-    // The Creator and Format are used to determine which application to open the file with.
-    _creator?: string
-    _format?: string
-
-    // Standard fields
-    _label?: string
-    _comments?: string
-
-    // The URL if the file is a 'shortcut' type
-    _url?: string
-
-    // Icon data
-    _icon?: string
-    _badge?: ReactNode
-
-    // Modification data
-    _createdOn?: Date
-    _modifiedOn?: Date
-    _versions?: ClassicyFileSystemEntry[]
-
-    // Entry Settings
-    _readOnly?: boolean // The file cannot be modified. It's name can be changed.
-    _nameLocked?: boolean // If true, the name cannot be changed.
-    _trashed?: boolean // If true, this entry is in the trash and will not show, except in the Trash.
-    _system?: boolean // The file is a system file and cannot be modified. It is also marked with an additional icon.
-    _invisible?: boolean // The file is not normally visible, but can be accessed by apps.
-
-    // Folders
-    // Used for stat-ing directories
-    _count?: number
-    _countHidden?: number
-    _path?: string
-
-    // Files
-    // The contents of the file.
-    _data?: any
-
-    // Used for stat-ing directories and files.
-    _size?: number
-
-    // Optional useful field for storing the name.
-    _name?: string
-}
-
-export type ClassicyFileSystemEntry = {
-    [entry: string]: any
-} & ClassicyFileSystemEntryMetadata