Implemented strict linting standards and prettier formatting config. (#248)

* Implemented strict linting standards and prettier formatting config.

* More linter fixes and type updates.

* More linter updates and type fixes

* Remove noisy comments

* Linter and type updates

* Linter, formatting and type updates.

* Linter updates

* Type updates

* Type updates

* fixed all linter errors

* Fixed all linting, formatting and type issues.

* Resolve merge conflicts.
This commit is contained in:
Jas Singh
2024-09-14 16:20:05 -07:00
committed by GitHub
parent ff13e3dd3c
commit 2c72cc66d8
222 changed files with 13141 additions and 8433 deletions

View File

@@ -1,220 +1,63 @@
import { Opt } from "lib/option"
import Gdk from "gi://Gdk"
import icons from "lib/icons"
import { RowProps } from "lib/types/options"
import { Variable } from "types/variable";
import Wallpaper from "services/Wallpaper";
import { dependencies as checkDependencies } from "lib/utils";
import options from "options";
import { importFiles, saveFileDialog } from "./FileChooser";
import { RowProps } from 'lib/types/options';
import { Variable } from 'types/variable';
import { BoxWidget } from 'lib/types/widget';
import { numberInputter } from './components/number';
import { objectInputter } from './components/object';
import { stringInputter } from './components/string';
import { booleanInputter } from './components/boolean';
import { imageInputter } from './components/image';
import { importInputter } from './components/import';
import { wallpaperInputter } from './components/wallpaper';
import { colorInputter } from './components/color';
import { enumInputter } from './components/enum';
import { fontInputter } from './components/font';
const EnumSetter = (opt: Opt<string>, values: string[]) => {
const lbl = Widget.Label({ label: opt.bind().as(v => `${v}`) })
const step = (dir: 1 | -1) => {
const i = values.findIndex(i => i === lbl.label)
opt.setValue(dir > 0
? i + dir > values.length - 1 ? values[0] : values[i + dir]
: i + dir < 0 ? values[values.length - 1] : values[i + dir],
)
}
const next = Widget.Button({
child: Widget.Icon(icons.ui.arrow.right),
on_clicked: () => step(+1),
})
const prev = Widget.Button({
child: Widget.Icon(icons.ui.arrow.left),
on_clicked: () => step(-1),
})
return Widget.Box({
class_name: "enum-setter",
children: [lbl, prev, next],
})
}
export const Inputter = <T>({
opt,
type = typeof opt.value as RowProps<T>["type"],
enums,
max = 1000000,
min = 0,
increment = 1,
disabledBinding,
dependencies,
exportData,
}: RowProps<T>,
export const Inputter = <T extends string | number | boolean | object>(
{
opt,
type = typeof opt.value as RowProps<T>['type'],
enums,
disabledBinding,
dependencies,
exportData,
min = 0,
max = 1000000,
increment = 1,
}: RowProps<T>,
className: string,
isUnsaved: Variable<boolean>
) => {
isUnsaved: Variable<boolean>,
): BoxWidget => {
return Widget.Box({
vpack: "center",
class_name: /export|import/.test(type || "") ? "" : "inputter-container",
setup: self => {
vpack: 'center',
class_name: /export|import/.test(type || '') ? '' : 'inputter-container',
setup: (self) => {
switch (type) {
case "number": return self.children = [
Widget.Box({
class_name: "unsaved-icon-container",
child: isUnsaved.bind("value").as(unsvd => {
if (unsvd) {
return Widget.Icon({
class_name: "unsaved-icon",
icon: icons.ui.warning,
tooltipText: "Press 'Enter' to apply your changes."
})
}
return Widget.Box();
}),
}),
Widget.SpinButton({
setup(self) {
self.set_range(min, max)
self.set_increments(1 * increment, 5 * increment)
self.on("value-changed", () => {
opt.value = self.value as T;
})
self.hook(opt, () => {
self.value = opt.value as number;
isUnsaved.value = Number(self.text) !== opt.value as number;
})
self.connect("key-release-event", () => {
isUnsaved.value = Number(self.text) !== opt.value as number;
})
},
})
]
case "float":
case "object": return self.children = [
Widget.Box({
class_name: "unsaved-icon-container",
child: isUnsaved.bind("value").as(unsvd => {
if (unsvd) {
return Widget.Icon({
class_name: "unsaved-icon",
icon: icons.ui.warning,
tooltipText: "Press 'Enter' to apply your changes."
})
}
return Widget.Box();
}),
}),
Widget.Entry({
class_name: className,
on_change: self => isUnsaved.value = self.text !== JSON.stringify(opt.value),
on_accept: self => opt.value = JSON.parse(self.text || ""),
setup: self => self.hook(opt, () => {
self.text = JSON.stringify(opt.value);
isUnsaved.value = self.text !== JSON.stringify(opt.value);
})
})
]
case "string": return self.children = [
Widget.Box({
class_name: "unsaved-icon-container",
child: isUnsaved.bind("value").as(unsvd => {
if (unsvd) {
return Widget.Icon({
class_name: "unsaved-icon",
icon: icons.ui.warning,
tooltipText: "Press 'Enter' to apply your changes."
})
}
return Widget.Box();
}),
}),
Widget.Entry({
class_name: isUnsaved.bind("value").as(unsaved => unsaved ? "unsaved" : ""),
on_change: self => isUnsaved.value = self.text !== opt.value,
on_accept: self => {
opt.value = self.text as T;
},
setup: self => self.hook(opt, () => {
isUnsaved.value = self.text !== opt.value;
self.text = opt.value as string;
}),
})
]
case "enum": return self.child = EnumSetter(opt as unknown as Opt<string>, enums!)
case "boolean": return self.child = Widget.Switch({
sensitive: disabledBinding !== undefined ? disabledBinding.bind("value").as(disabled => !disabled) : true,
})
.on("notify::active", self => {
if (disabledBinding !== undefined && disabledBinding.value) {
return;
}
if (self.active && dependencies !== undefined && !dependencies.every(d => checkDependencies(d))) {
self.active = false;
return;
}
opt.value = self.active as T
})
.hook(opt, self => {
self.active = opt.value as boolean
})
case "img": return self.child = Widget.FileChooserButton({
class_name: "image-chooser",
on_file_set: ({ uri }) => { opt.value = uri!.replace("file://", "") as T },
})
case "config_import": return self.child = Widget.Box({
children: [
Widget.Button({
class_name: "options-import",
label: "import",
on_clicked: () => {
importFiles(exportData?.themeOnly as boolean);
}
}),
Widget.Button({
class_name: "options-export",
label: "export",
on_clicked: () => {
saveFileDialog(exportData?.filePath as string, exportData?.themeOnly as boolean);
}
}),
]
})
case "wallpaper": return self.child = Widget.FileChooserButton({
on_file_set: ({ uri }) => {
opt.value = uri!.replace("file://", "") as T;
if (options.wallpaper.enable.value) {
Wallpaper.set(uri!.replace("file://", ""));
}
},
})
case "font": return self.child = Widget.FontButton({
show_size: false,
use_size: false,
setup: self => self
.hook(opt, () => self.font = opt.value as string)
.on("font-set", ({ font }) => opt.value = font!
.split(" ").slice(0, -1).join(" ") as T),
})
case "color": return self.child = Widget.ColorButton()
.hook(opt, self => {
const rgba = new Gdk.RGBA()
rgba.parse(opt.value as string)
self.rgba = rgba
})
.on("color-set", ({ rgba: { red, green, blue } }) => {
const hex = (n: number) => {
const c = Math.floor(255 * n).toString(16)
return c.length === 1 ? `0${c}` : c
}
opt.value = `#${hex(red)}${hex(green)}${hex(blue)}` as T
})
default: return self.child = Widget.Label({
label: `no setter with type ${type}`,
})
case 'number':
return numberInputter(self, opt, min, max, increment, isUnsaved);
case 'float':
case 'object':
return objectInputter(self, opt, isUnsaved, className);
case 'string':
return stringInputter(self, opt, isUnsaved);
case 'enum':
return enumInputter(self, opt, enums!);
case 'boolean':
return booleanInputter(self, opt, disabledBinding, dependencies);
case 'img':
return imageInputter(self, opt);
case 'config_import':
return importInputter(self, exportData);
case 'wallpaper':
return wallpaperInputter(self, opt);
case 'font':
return fontInputter(self, opt);
case 'color':
return colorInputter(self, opt);
default:
return (self.child = Widget.Label({
label: `No setter with type ${type}`,
}));
}
}
})
}
},
});
};