notu 0.1.0

package/src/models/NoteTag.ts

@@ -0,0 +1,71 @@
+'use strict';
+
+import Note from './Note';
+import ModelWithState from './ModelWithState';
+import Tag from './Tag';
+
+
+export default class NoteTag extends ModelWithState<NoteTag> {
+    private _noteId: number = 0;
+    get noteId(): number { return this._noteId; }
+    set noteId(value: number) {
+        if (value !== this._noteId) {
+            this._noteId = value;
+            if (value !== this.note?.id ?? 0)
+                this._note = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _note: Note = null;
+    get note(): Note { return this._note; }
+    set note(value: Note) {
+        this._note = value;
+        this.noteId = value?.id ?? 0;
+    }
+
+
+    private _tagId: number = 0;
+    get tagId(): number { return this._tagId; }
+    set tagId(value: number) {
+        if (value !== this._tagId) {
+            this._tagId = value;
+            if (value !== this.tag?.id ?? 0)
+                this._tag = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _tag: Tag = null;
+    get tag(): Tag { return this._tag; }
+    set tag(value: Tag) {
+        this._tag = value;
+        this.tagId = value?.id ?? 0;
+    }
+
+
+    duplicate(): NoteTag {
+        const output = new NoteTag();
+        output.noteId = this.noteId;
+        output.tagId = this.tagId;
+        return output;
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        let output = null;
+
+        if (this.noteId <= 0 && !this.isNew)
+            output = 'NoteTag noteId must be greater than zero';
+        else if (this.tagId <= 0)
+            output = 'NoteTag tagId must be greater than zero';
+        else if (this.noteId == this.tagId)
+            output = 'NoteTag cannot link a note to its own tag';
+
+        if (throwError && output != null)
+            throw Error(output);
+        return output == null;
+    }
+}

package/src/models/Space.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from 'vitest';
+import Space from './Space';
+
+
+test('Gets initiated as new', () => {
+    const space = new Space();
+    expect(space.isNew).toBe(true);
+});
+
+
+test('Set name marks space as dirty if currently clean', () => {
+    const space = new Space().clean();
+    space.name = 'asdf';
+    expect(space.isDirty).toBe(true);
+});
+
+test('Set name doesnt change space state if new', () => {
+    const space = new Space().new();
+    space.name = 'asdf';
+    expect(space.isNew).toBe(true);
+});
+
+test('Set name doesnt change space state if value not different', () => {
+    const space = new Space().clean();
+    space.name = '';
+    expect(space.isClean).toBe(true);
+});
+
+
+test('Space can be initiated with name in constructor', () => {
+    const space = new Space('hello');
+    expect(space.name).toBe('hello');
+});
+
+test('can duplicate itself', () => {
+    const space = new Space('hello').clean();
+    const copy = space.duplicate();
+    expect(copy.id).toBe(space.id);
+    expect(copy.name).toBe(space.name);
+    expect(copy.state).toBe(space.state);
+});
+
+test('validate fails if not new and id <= 0', () => {
+    const model = new Space().clean();
+    model.id = 0;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const model = new Space().clean();
+    model.id = 0;
+    expect(() => model.validate(true)).toThrowError();
+});

package/src/models/Space.ts

@@ -0,0 +1,46 @@
+'use strict';
+
+import ModelWithState from './ModelWithState';
+
+
+export default class Space extends ModelWithState<Space> {
+    id: number = 0;
+
+    
+    private _name: string = '';
+    get name(): string { return this._name; }
+    set name(value: string) {
+        if (value !== this._name) {
+            this._name = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    constructor(name: string = '') {
+        super();
+        this._name = name;
+    }
+
+
+    duplicate(): Space {
+        const output = new Space();
+        output.id = this.id;
+        output.name = this.name;
+        output.state = this.state;
+        return output;
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        let output = null;
+
+        if (!this.isNew && this.id <= 0)
+            output = 'Space id must be greater than zero if in non-new state.';
+
+        if (throwError && output != null)
+            throw Error(output);
+        return output == null;
+    }
+}

package/src/models/Tag.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from 'vitest';
+import Tag from './Tag';
+
+
+test('Gets initiated as new', () => {
+    const tag = new Tag();
+    expect(tag.isNew).toBe(true);
+});
+
+
+test('Set id marks tag as dirty if currently clean', () => {
+    const tag = new Tag().clean();
+    tag.id = 123;
+    expect(tag.isDirty).toBe(true);
+});
+
+test('Set id doesnt change tag state if new', () => {
+    const tag = new Tag().new();
+    tag.id = 123;
+    expect(tag.isNew).toBe(true);
+});
+
+test('Set id doesnt change tag state if value not different', () => {
+    const tag = new Tag().clean();
+    tag.id = 0;
+    expect(tag.isClean).toBe(true);
+});
+
+
+test('Set name marks tag as dirty if currently clean', () => {
+    const tag = new Tag().clean();
+    tag.name = 'asdf';
+    expect(tag.isDirty).toBe(true);
+});
+
+test('Set name doesnt change tag state if new', () => {
+    const tag = new Tag().new();
+    tag.name = 'asdf';
+    expect(tag.isNew).toBe(true);
+});
+
+test('Set name doesnt change tag state if value not different', () => {
+    const tag = new Tag().clean();
+    tag.name = '';
+    expect(tag.isClean).toBe(true);
+});
+
+test('Tag can be initiated with name in constructor', () => {
+    const tag = new Tag('hello');
+    expect(tag.name).toBe('hello');
+});
+
+test('can duplicate itself', () => {
+    const tag = new Tag('hello');
+    const copy = tag.duplicate();
+    expect(copy.id).toBe(tag.id);
+    expect(copy.name).toBe(tag.name);
+    expect(copy.state).toBe(tag.state);
+});
+
+test('validate fails if not new and id <= 0', () => {
+    const model = new Tag().clean();
+    model.id = 0;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const model = new Tag().clean();
+    model.id = 0;
+    expect(() => model.validate(true)).toThrowError();
+});

package/src/models/Tag.ts

@@ -0,0 +1,54 @@
+'use strict';
+
+import ModelWithState from './ModelWithState';
+
+
+export default class Tag extends ModelWithState<Tag> {
+    private _id: number = 0;
+    get id(): number { return this._id; }
+    set id(value: number) {
+        if (value !== this._id) {
+            this._id = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    
+    private _name: string = '';
+    get name(): string { return this._name; }
+    set name(value: string) {
+        if (value !== this._name) {
+            this._name = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    constructor(name: string = '') {
+        super();
+        this._name = name;
+    }
+
+
+    duplicate(): Tag {
+        const output = new Tag();
+        output.id = this.id;
+        output.name = this.name;
+        output.state = this.state;
+        return output;
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        let output = null;
+
+        if (!this.isNew && this.id <= 0)
+            output = 'Tag id must be greater than zero if in non-new state.';
+
+        if (throwError && output != null)
+            throw Error(output);
+        return output == null;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
+    "strict": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+    build: {
+        lib: {
+            name: 'notu',
+            entry: './src/index.ts'
+        }
+    }
+});