fontastic 0.2.0 → 1.0.1

package/.github/workflows/macos.yml

@@ -68,10 +68,3 @@ jobs:
 
     - name: Run headless e2e test
       run: npm run e2e
-
-    - name: Build the app
-      uses: nick-fields/retry@v3
-      with:
-        timeout_minutes: 15
-        max_attempts: 3
-        command: npm run electron:build

package/.github/workflows/ubuntu.yml

@@ -78,10 +78,3 @@ jobs:
       uses: GabrielBB/xvfb-action@v1
       with:
         run: npm run e2e
-
-    - name: Build the app
-      uses: nick-fields/retry@v3
-      with:
-        timeout_minutes: 15
-        max_attempts: 3
-        command: npm run electron:build

package/.github/workflows/windows.yml

@@ -72,10 +72,3 @@ jobs:
 
     - name: Run headless e2e test
       run: npm run e2e
-
-    - name: Build the app
-      uses: nick-fields/retry@v3
-      with:
-        timeout_minutes: 15
-        max_attempts: 3
-        command: npm run electron:build

package/README.md

@@ -17,6 +17,7 @@ Fontastic is a cross-platform font management and cataloging application built w
 ## Features
 
 - Nested collections — organize fonts into hierarchical groups with drag-and-drop
+- Smart collections — auto-populate collections using rule-based filters on font metadata
 - Advanced search — quickly find fonts with powerful search and filtering
 - Glyph inspector — browse and examine individual characters and Unicode points
 - Waterfall preview — compare text rendering across multiple sizes at a glance

package/app/core/ConnectionManager.js

@@ -15,7 +15,7 @@ const repository_1 = require("../database/repository");
 const StorageType_1 = require("../enums/StorageType");
 class ConnectionManager {
     constructor(configManager) {
-        this.schemas = [entity_1.Collection, entity_1.Store, entity_1.Logger];
+        this.schemas = [entity_1.Collection, entity_1.Store, entity_1.Logger, entity_1.SmartCollection];
         this.subscribers = [];
         this.migrations = [];
         this.omitables = ['title', 'description', 'enabled'];
@@ -89,6 +89,12 @@ class ConnectionManager {
     getStoreRepository() {
         return this.getStore().extend(repository_1.StoreRepository);
     }
+    getSmartCollection() {
+        return this.dataSource.getRepository(entity_1.SmartCollection);
+    }
+    getSmartCollectionRepository() {
+        return this.getSmartCollection().extend(repository_1.SmartCollectionRepository);
+    }
 }
 exports.default = ConnectionManager;
 //# sourceMappingURL=ConnectionManager.js.map

package/app/core/ConnectionManager.ts

@@ -1,6 +1,6 @@
 import { DataSource, DataSourceOptions } from 'typeorm';
-import { Collection, Store, Logger } from '../database/entity';
-import { CollectionRepository, LoggerRepository, StoreRepository } from '../database/repository';
+import { Collection, Store, Logger, SmartCollection } from '../database/entity';
+import { CollectionRepository, LoggerRepository, SmartCollectionRepository, StoreRepository } from '../database/repository';
 import ConfigManager from './ConfigManager';
 import { StorageType } from '../enums/StorageType';
 
@@ -10,7 +10,7 @@ export default class ConnectionManager {
 
   dataSource: DataSource;
 
-  schemas: any[] = [Collection, Store, Logger];
+  schemas: any[] = [Collection, Store, Logger, SmartCollection];
   subscribers: any[] = [];
   migrations: any[] = [];
 
@@ -104,4 +104,12 @@ export default class ConnectionManager {
   getStoreRepository() {
     return this.getStore().extend(StoreRepository);
   }
+
+  getSmartCollection() {
+    return this.dataSource.getRepository(SmartCollection);
+  }
+
+  getSmartCollectionRepository() {
+    return this.getSmartCollection().extend(SmartCollectionRepository);
+  }
 }

package/app/core/MessageHandler.js

@@ -141,6 +141,30 @@ class MessageHandler {
             yield this.connectionManager.getCollectionRepository().updateCollectionCounts(items);
             return yield this.fetchCollectionsWithCounts({});
         }));
+        // Smart Collection
+        this.handle(ChannelType_1.ChannelType.IPC_SMART_COLLECTION_FIND, (_event) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.connectionManager.getSmartCollectionRepository().fetchAll();
+        }));
+        this.handle(ChannelType_1.ChannelType.IPC_SMART_COLLECTION_CREATE, (_event, args) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.connectionManager.getSmartCollectionRepository().createSmartCollection(args);
+        }));
+        this.handle(ChannelType_1.ChannelType.IPC_SMART_COLLECTION_UPDATE, (_event, args) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.connectionManager.getSmartCollectionRepository().updateSmartCollection(args.id, args.data);
+        }));
+        this.handle(ChannelType_1.ChannelType.IPC_SMART_COLLECTION_DELETE, (_event, args) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.connectionManager.getSmartCollectionRepository().deleteSmartCollection(args.id);
+        }));
+        this.handle(ChannelType_1.ChannelType.IPC_SMART_COLLECTION_EVALUATE, (_event, args) => __awaiter(this, void 0, void 0, function* () {
+            const sc = yield this.connectionManager.getSmartCollectionRepository().findOneBy({ id: args.id });
+            if (!sc)
+                return [[], 0];
+            const rules = JSON.parse(sc.rules);
+            return yield this.connectionManager.getStoreRepository().evaluateSmartRules(rules, sc.match_type, {
+                skip: args.skip,
+                take: args.take,
+                order: args.order,
+            });
+        }));
         // Store
         this.handle(ChannelType_1.ChannelType.IPC_STORE_FIND, (_event, args) => __awaiter(this, void 0, void 0, function* () {
             return yield this.connectionManager.getStore().find(args);

package/app/core/MessageHandler.ts

@@ -184,6 +184,35 @@ export default class MessageHandler {
       return await this.fetchCollectionsWithCounts({});
     });
 
+    // Smart Collection
+
+    this.handle(ChannelType.IPC_SMART_COLLECTION_FIND, async (_event: IpcMainEvent) => {
+      return await this.connectionManager.getSmartCollectionRepository().fetchAll();
+    });
+
+    this.handle(ChannelType.IPC_SMART_COLLECTION_CREATE, async (_event: IpcMainEvent, args: any) => {
+      return await this.connectionManager.getSmartCollectionRepository().createSmartCollection(args);
+    });
+
+    this.handle(ChannelType.IPC_SMART_COLLECTION_UPDATE, async (_event: IpcMainEvent, args: any) => {
+      return await this.connectionManager.getSmartCollectionRepository().updateSmartCollection(args.id, args.data);
+    });
+
+    this.handle(ChannelType.IPC_SMART_COLLECTION_DELETE, async (_event: IpcMainEvent, args: any) => {
+      return await this.connectionManager.getSmartCollectionRepository().deleteSmartCollection(args.id);
+    });
+
+    this.handle(ChannelType.IPC_SMART_COLLECTION_EVALUATE, async (_event: IpcMainEvent, args: any) => {
+      const sc = await this.connectionManager.getSmartCollectionRepository().findOneBy({ id: args.id });
+      if (!sc) return [[], 0];
+      const rules = JSON.parse(sc.rules);
+      return await this.connectionManager.getStoreRepository().evaluateSmartRules(rules, sc.match_type, {
+        skip: args.skip,
+        take: args.take,
+        order: args.order,
+      });
+    });
+
     // Store
 
     this.handle(ChannelType.IPC_STORE_FIND, async (_event: IpcMainEvent, args: any) => {

package/app/core/menu/templates/DarwinTemplate.js

@@ -68,6 +68,21 @@ class DarwinTemplate {
                     this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
                 },
             },
+            { type: 'separator' },
+            {
+                label: 'Expand Collections',
+                accelerator: 'Alt+Command+E',
+                click: () => {
+                    this.mainWindow.webContents.send(enums_1.ChannelType.IPC_TOGGLE_PANEL, 'expand-collections');
+                },
+            },
+            {
+                label: 'Collapse Collections',
+                accelerator: 'Alt+Command+Shift+E',
+                click: () => {
+                    this.mainWindow.webContents.send(enums_1.ChannelType.IPC_TOGGLE_PANEL, 'collapse-collections');
+                },
+            },
         ];
         if (!this.isProduction) {
             items.push({ type: 'separator' }, {

package/app/core/menu/templates/DarwinTemplate.ts

@@ -80,6 +80,21 @@ export default class DarwinTemplate {
           this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
         },
       },
+      { type: 'separator' },
+      {
+        label: 'Expand Collections',
+        accelerator: 'Alt+Command+E',
+        click: () => {
+          this.mainWindow.webContents.send(ChannelType.IPC_TOGGLE_PANEL, 'expand-collections');
+        },
+      },
+      {
+        label: 'Collapse Collections',
+        accelerator: 'Alt+Command+Shift+E',
+        click: () => {
+          this.mainWindow.webContents.send(ChannelType.IPC_TOGGLE_PANEL, 'collapse-collections');
+        },
+      },
     ];
 
     if (!this.isProduction) {

package/app/core/menu/templates/SystemTemplate.js

@@ -65,6 +65,21 @@ class SystemTemplate {
                     this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
                 },
             },
+            { type: 'separator' },
+            {
+                label: 'Expand Collections',
+                accelerator: 'Alt+Ctrl+E',
+                click: () => {
+                    this.mainWindow.webContents.send(enums_1.ChannelType.IPC_TOGGLE_PANEL, 'expand-collections');
+                },
+            },
+            {
+                label: 'Collapse Collections',
+                accelerator: 'Alt+Ctrl+Shift+E',
+                click: () => {
+                    this.mainWindow.webContents.send(enums_1.ChannelType.IPC_TOGGLE_PANEL, 'collapse-collections');
+                },
+            },
         ];
         if (!this.isProduction) {
             items.push({ type: 'separator' }, {

package/app/core/menu/templates/SystemTemplate.ts

@@ -72,6 +72,21 @@ export default class SystemTemplate {
           this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
         },
       },
+      { type: 'separator' },
+      {
+        label: 'Expand Collections',
+        accelerator: 'Alt+Ctrl+E',
+        click: () => {
+          this.mainWindow.webContents.send(ChannelType.IPC_TOGGLE_PANEL, 'expand-collections');
+        },
+      },
+      {
+        label: 'Collapse Collections',
+        accelerator: 'Alt+Ctrl+Shift+E',
+        click: () => {
+          this.mainWindow.webContents.send(ChannelType.IPC_TOGGLE_PANEL, 'collapse-collections');
+        },
+      },
     ];
 
     if (!this.isProduction) {

package/app/database/entity/SmartCollection.schema.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartCollection = void 0;
+const typeorm_1 = require("typeorm");
+let SmartCollection = class SmartCollection {
+};
+exports.SmartCollection = SmartCollection;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)(),
+    __metadata("design:type", Number)
+], SmartCollection.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        length: 100,
+    }),
+    __metadata("design:type", String)
+], SmartCollection.prototype, "title", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'text',
+    }),
+    __metadata("design:type", String)
+], SmartCollection.prototype, "rules", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        length: 3,
+        default: 'AND',
+    }),
+    __metadata("design:type", String)
+], SmartCollection.prototype, "match_type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'smallint',
+        default: 0,
+    }),
+    __metadata("design:type", Number)
+], SmartCollection.prototype, "orderby", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'smallint',
+        default: 0,
+    }),
+    __metadata("design:type", Number)
+], SmartCollection.prototype, "enabled", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)(),
+    __metadata("design:type", Date)
+], SmartCollection.prototype, "created", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)(),
+    __metadata("design:type", Date)
+], SmartCollection.prototype, "updated", void 0);
+exports.SmartCollection = SmartCollection = __decorate([
+    (0, typeorm_1.Entity)()
+], SmartCollection);
+//# sourceMappingURL=SmartCollection.schema.js.map

package/app/database/entity/SmartCollection.schema.ts

@@ -0,0 +1,39 @@
+import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity()
+export class SmartCollection {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({
+    length: 100,
+  })
+  title: string;
+
+  @Column({
+    type: 'text',
+  })
+  rules: string;
+
+  @Column({
+    type: 'varchar',
+    length: 3,
+    default: 'AND',
+  })
+  match_type: string;
+
+  @Column({
+    type: 'smallint',
+    default: 0,
+  })
+  orderby: number;
+
+  @Column({
+    type: 'smallint',
+    default: 0,
+  })
+  enabled: number;
+
+  @CreateDateColumn() public created: Date;
+  @UpdateDateColumn() public updated: Date;
+}

package/app/database/entity/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Collection.schema"), exports);
 __exportStar(require("./Logger.schema"), exports);
+__exportStar(require("./SmartCollection.schema"), exports);
 __exportStar(require("./Store.schema"), exports);
 //# sourceMappingURL=index.js.map

package/app/database/entity/index.ts

@@ -1,3 +1,4 @@
 export * from './Collection.schema';
 export * from './Logger.schema';
-export * from './Store.schema';
+export * from './SmartCollection.schema';
+export * from './Store.schema';

package/app/database/repository/SmartCollection.repository.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartCollectionRepository = void 0;
+const entity_1 = require("../entity");
+exports.SmartCollectionRepository = {
+    fetchAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.createQueryBuilder('sc').orderBy('sc.orderby', 'ASC').addOrderBy('LOWER(sc.title)', 'ASC').getMany();
+        });
+    },
+    createSmartCollection(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createQueryBuilder()
+                .insert()
+                .into(entity_1.SmartCollection)
+                .values({
+                title: args.title,
+                rules: args.rules,
+                match_type: args.match_type,
+            })
+                .execute();
+            return this.fetchAll();
+        });
+    },
+    updateSmartCollection(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createQueryBuilder().update(entity_1.SmartCollection).set(data).where('id = :id', { id }).execute();
+            return this.fetchAll();
+        });
+    },
+    deleteSmartCollection(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createQueryBuilder().delete().from(entity_1.SmartCollection).where('id = :id', { id }).execute();
+            return this.fetchAll();
+        });
+    },
+};
+//# sourceMappingURL=SmartCollection.repository.js.map

package/app/database/repository/SmartCollection.repository.ts

@@ -0,0 +1,30 @@
+import { SmartCollection } from '../entity';
+
+export const SmartCollectionRepository = {
+  async fetchAll(): Promise<SmartCollection[]> {
+    return this.createQueryBuilder('sc').orderBy('sc.orderby', 'ASC').addOrderBy('LOWER(sc.title)', 'ASC').getMany();
+  },
+
+  async createSmartCollection(args: { title: string; rules: string; match_type: string }) {
+    await this.createQueryBuilder()
+      .insert()
+      .into(SmartCollection)
+      .values({
+        title: args.title,
+        rules: args.rules,
+        match_type: args.match_type,
+      })
+      .execute();
+    return this.fetchAll();
+  },
+
+  async updateSmartCollection(id: number, data: Partial<SmartCollection>) {
+    await this.createQueryBuilder().update(SmartCollection).set(data).where('id = :id', { id }).execute();
+    return this.fetchAll();
+  },
+
+  async deleteSmartCollection(id: number) {
+    await this.createQueryBuilder().delete().from(SmartCollection).where('id = :id', { id }).execute();
+    return this.fetchAll();
+  },
+};

package/app/database/repository/Store.repository.js

@@ -307,6 +307,113 @@ exports.StoreRepository = {
                 .catch((err) => console.log('insert-error', err));
         });
     },
+    evaluateSmartRules(rules_1, matchType_1) {
+        return __awaiter(this, arguments, void 0, function* (rules, matchType, options = {}) {
+            const db = this.createQueryBuilder();
+            const textFields = [
+                'file_name',
+                'file_path',
+                'compatible_full_name',
+                'copyright',
+                'description',
+                'designer',
+                'designer_url',
+                'font_family',
+                'font_subfamily',
+                'full_name',
+                'license',
+                'license_url',
+                'manufacturer',
+                'manufacturer_url',
+                'post_script_name',
+                'preferred_family',
+                'preferred_sub_family',
+                'sample_text',
+                'trademark',
+                'unique_id',
+                'version',
+            ];
+            const booleanFields = ['favorite', 'system', 'installable', 'temporary'];
+            const numericFields = ['file_size'];
+            const dateFields = ['created'];
+            if (rules.length > 0) {
+                const conditions = rules.map((rule, idx) => {
+                    const field = `store.${rule.field}`;
+                    const paramName = `p${idx}`;
+                    return (qb) => {
+                        if (textFields.includes(rule.field)) {
+                            const val = String(rule.value).toLowerCase();
+                            switch (rule.operator) {
+                                case 'contains':
+                                    qb.where(`LOWER(${field}) LIKE :${paramName}`, { [paramName]: `%${val}%` });
+                                    break;
+                                case 'equals':
+                                    qb.where(`LOWER(${field}) = :${paramName}`, { [paramName]: val });
+                                    break;
+                                case 'starts_with':
+                                    qb.where(`LOWER(${field}) LIKE :${paramName}`, { [paramName]: `${val}%` });
+                                    break;
+                                case 'ends_with':
+                                    qb.where(`LOWER(${field}) LIKE :${paramName}`, { [paramName]: `%${val}` });
+                                    break;
+                                default:
+                                    qb.where(`LOWER(${field}) LIKE :${paramName}`, { [paramName]: `%${val}%` });
+                            }
+                        }
+                        else if (rule.field === 'file_type') {
+                            qb.where(`${field} = :${paramName}`, { [paramName]: rule.value });
+                        }
+                        else if (booleanFields.includes(rule.field)) {
+                            const boolVal = rule.operator === 'is_not' ? 0 : 1;
+                            qb.where(`${field} = :${paramName}`, { [paramName]: boolVal });
+                        }
+                        else if (numericFields.includes(rule.field)) {
+                            if (rule.operator === 'greater_than') {
+                                qb.where(`${field} > :${paramName}`, { [paramName]: rule.value });
+                            }
+                            else if (rule.operator === 'less_than') {
+                                qb.where(`${field} < :${paramName}`, { [paramName]: rule.value });
+                            }
+                            else {
+                                qb.where(`${field} = :${paramName}`, { [paramName]: rule.value });
+                            }
+                        }
+                        else if (dateFields.includes(rule.field)) {
+                            if (rule.operator === 'greater_than') {
+                                qb.where(`${field} >= :${paramName}`, { [paramName]: rule.value });
+                            }
+                            else if (rule.operator === 'less_than') {
+                                qb.where(`${field} <= :${paramName}`, { [paramName]: rule.value });
+                            }
+                            else {
+                                qb.where(`${field} = :${paramName}`, { [paramName]: rule.value });
+                            }
+                        }
+                    };
+                });
+                const joiner = matchType === 'OR' ? 'orWhere' : 'andWhere';
+                conditions.forEach((condition, i) => {
+                    if (i === 0) {
+                        db.where(new typeorm_1.Brackets(condition));
+                    }
+                    else {
+                        db[joiner](new typeorm_1.Brackets(condition));
+                    }
+                });
+            }
+            if (options.take) {
+                db.limit(options.take);
+            }
+            if (options.skip) {
+                db.offset(options.skip);
+            }
+            if (options.order && options.order.column) {
+                const direction = options.order.direction === 'DESC' ? 'DESC' : 'ASC';
+                db.orderBy(`store.${options.order.column}`, direction);
+            }
+            return yield db.getManyAndCount();
+        });
+    },
     fetchSystemStats() {
         return __awaiter(this, void 0, void 0, function* () {
             const rowCount = yield this.createQueryBuilder().select('COUNT(*)', 'total').getRawOne();