A fully open source & end-to-end encrypted note taking alternative to Evernote.
TypeScript asp-net-coredotnet-coreelectronfosshacktoberfestnote-managmentnote-takingnote-taking-appnotebooknotesnotes-appopen-sourceopensourceprivacyproductivityreactreact-nativereactjsself-hosted
/*
This file is part of the Notesnook project (https://notesnook.com/)
Copyright (C) 2023 Streetwriters (Private) Limited
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
import { SubscriptionPlan } from "@notesnook/core";
import { strings } from "@notesnook/intl";
import { database as db } from "../database.js";
type CaptionValue = ("infinity" | (string & {})) | boolean | number;
type Limit<TCaption extends CaptionValue = CaptionValue> = {
caption: TCaption;
value: number | boolean;
isAllowed: (value?: number) => Promise<boolean> | boolean;
};
type FeatureAvailability<TCaption extends CaptionValue = CaptionValue> = {
free: Limit<TCaption>;
essential: Limit<TCaption>;
pro: Limit<TCaption>;
believer: Limit<TCaption>;
legacyPro: Limit<TCaption>;
};
export type Feature<TCaption extends CaptionValue = CaptionValue> = {
id: string;
title: string;
error: (limit: Limit) => string;
used?: () => Promise<number> | number;
availability: FeatureAvailability<TCaption>;
};
export type FeatureResult<TId extends FeatureId = FeatureId> = {
id: TId;
isAllowed: boolean;
availableOn?: SubscriptionPlan;
caption: Caption<TId>;
error: string;
};
type CaptionsFromAvailability<A> = A extends Record<
string,
{ caption: infer C }
>
? C
: never;
function createFeature<A extends FeatureAvailability>(
feature: Omit<Feature, "error" | "availability"> & {
error?: Feature["error"];
availability: A;
}
): Feature<CaptionsFromAvailability<A>> {
const f = {
...feature,
error:
feature.error ??
((l: Limit): string =>
typeof l.caption === "number"
? strings.reachedLimitOf(l.caption, feature.title.toLowerCase())
: strings.featureNotAvailableOnPlan(feature.title))
};
Object.defineProperty(f, "title", {
get() {
return feature.title;
},
enumerable: true,
configurable: true
});
return f as unknown as Feature<CaptionsFromAvailability<A>>;
}
function createLimit<
TCaption extends Limit["caption"],
TValue extends Limit["value"]
>(
caption: TCaption,
value?: TValue,
isAllowed?: (value: TValue) => Limit["isAllowed"]
): Limit<TCaption> {
const inferredValue =
value ??
(caption === "infinity"
? Infinity
: typeof caption === "boolean"
? !!caption
: typeof caption === "number"
? caption
: false);
return {
caption,
isAllowed: isAllowed
? isAllowed(inferredValue as TValue)
: caption === "infinity"
? alwaysInfinite
: inferredValue === false
? alwaysFalse
: inferredValue === true
? alwaysTrue
: typeof inferredValue === "number"
? lt(inferredValue)
: alwaysFalse,
value: inferredValue
};
}
export type FeatureId = keyof typeof features;
type Features = typeof features;
type Caption<TId extends FeatureId> =
Features[TId]["availability"][keyof FeatureAvailability]["caption"];
const features = {
storage: createFeature({
id: "storage",
get title() {
return strings.storage();
},
used: async () => {
const user = await db.user.getUser();
return user?.storageUsed || 0;
},
availability: {
free: createLimit("50MB/mo", 50 * 1024 * 1024),
essential: createLimit("1GB/mo", 1024 * 1024 * 1024),
pro: createLimit("10GB/mo", 10 * 1024 * 1024 * 1024),
believer: createLimit("25GB/mo", 25 * 1024 * 1024 * 1024),
legacyPro: createLimit("infinity", Infinity)
}
}),
fileSize: createFeature({
id: "fileSize",
get title() {
return strings.maximumFileSize();
},
error: (limit) =>
strings.cannotUploadFilesLargerThan(limit.caption as string | number),
availability: {
free: createLimit("10MB", 10 * 1024 * 1024),
essential: createLimit("100MB", 100 * 1024 * 1024),
pro: createLimit("1GB", 1024 * 1024 * 1024),
believer: createLimit("5GB", 5 * 1024 * 1024 * 1024),
legacyPro: createLimit("512MB", 512 * 1024 * 1024)
}
}),
fullQualityImages: createFeature({
id: "fullQualityImages",
get title() {
return strings.fullQualityImages();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
blockLinking: createFeature({
id: "blockLinking",
get title() {
return strings.blockLevelNoteLinks();
},
error: () =>
strings.featureNotAvailableOnPlan(strings.blockLevelNoteLinks()),
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
taskList: createFeature({
id: "taskList",
get title() {
return strings.taskList();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
outlineList: createFeature({
id: "outlineList",
get title() {
return strings.outlineList();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
callout: createFeature({
id: "callout",
get title() {
return strings.callout();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
colors: createFeature({
id: "colors",
get title() {
return strings.colors();
},
used: () => db.colors.all.count(),
availability: {
free: createLimit(7),
essential: createLimit(20),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
tags: createFeature({
id: "tags",
get title() {
return strings.tags();
},
used: () => db.tags.all.count(),
availability: {
free: createLimit(50),
essential: createLimit(500),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
notebooks: createFeature({
id: "notebooks",
get title() {
return strings.notebooks();
},
used: () => db.notebooks.all.count(),
availability: {
free: createLimit(50),
essential: createLimit(500),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
activeReminders: createFeature({
id: "activeReminders",
get title() {
return strings.activeReminders();
},
used: () => db.reminders.active.count(),
availability: {
free: createLimit(10),
essential: createLimit(50),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
shortcuts: createFeature({
id: "shortcuts",
get title() {
return strings.shortcuts();
},
used: () => db.shortcuts.all.length,
availability: {
free: createLimit(10),
essential: createLimit("infinity"),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
defaultNotebookAndTag: createFeature({
id: "defaultNotebookAndTag",
get title() {
return strings.defaultNotebookAndTag();
},
error: () => strings.cannotSetDefaultNotebookOrTag(),
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
recurringReminders: createFeature({
id: "recurringReminders",
get title() {
return strings.recurringReminders();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
pinNoteInNotification: createFeature({
id: "pinNoteInNotification",
get title() {
return strings.pinNoteInNotification();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
createNoteFromNotificationDrawer: createFeature({
id: "createNoteFromNotificationDrawer",
get title() {
return strings.createNoteFromNotificationDrawer();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
defaultSidebarTab: createFeature({
id: "defaultSidebarTab",
get title() {
return strings.defaultSidebarTab();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
customHomepage: createFeature({
id: "customHomepage",
get title() {
return strings.customHomepage();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
markdownShortcuts: createFeature({
id: "markdownShortcuts",
get title() {
return strings.mardownShortcuts();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
fontLigatures: createFeature({
id: "fontLigatures",
get title() {
return strings.fontLigatures();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
customToolbarPreset: createFeature({
id: "customToolbarPreset",
get title() {
return strings.customToolbarPreset();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
customizableSidebar: createFeature({
id: "customizableSidebar",
get title() {
return strings.customizableSidebar();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
disableTrashCleanup: createFeature({
id: "disableTrashCleanup",
get title() {
return strings.disableTrashCleanup();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
appLock: createFeature({
id: "appLock",
get title() {
return strings.appLock();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
maxNoteVersions: createFeature({
id: "maxNoteVersions",
get title() {
return strings.noteHistory();
},
availability: {
free: createLimit(100),
essential: createLimit(1000),
pro: createLimit("infinity"),
believer: createLimit("infinity"),
legacyPro: createLimit("infinity")
}
}),
fullOfflineMode: createFeature({
id: "fullOfflineMode",
get title() {
return strings.fullOfflineMode();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
syncControls: createFeature({
id: "syncControls",
get title() {
return strings.sync();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
monographLinksAndEmbeds: createFeature({
id: "monographLinksAndEmbeds",
get title() {
return strings.monographLinksAndEmbeds();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
monographAnalytics: createFeature({
id: "monographAnalytics",
get title() {
return strings.monographAnalytics();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
sms2FA: createFeature({
id: "sms2FA",
get title() {
return strings.twoFactorAuth();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
notesnookCircle: createFeature({
id: "notesnookCircle",
get title() {
return strings.notesnookCircle();
},
availability: {
free: createLimit(false),
essential: createLimit(true),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
androidLauncherShortcuts: createFeature({
id: "androidLauncherShortcuts",
get title() {
return strings.androidLauncherShortcuts();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
expiringNotes: createFeature({
id: "expiringNotes",
get title() {
return strings.expiringNotes();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
exportTableAsCsv: createFeature({
id: "exportTableAsCsv",
get title() {
return strings.exportTableAsCsv();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
}),
importCsvToTable: createFeature({
id: "importCsvToTable",
get title() {
return strings.importCsvToTable();
},
availability: {
free: createLimit(false),
essential: createLimit(false),
pro: createLimit(true),
believer: createLimit(true),
legacyPro: createLimit(true)
}
})
};
export async function isFeatureAvailable<TId extends FeatureId>(
id: TId,
value?: number
): Promise<FeatureResult<TId>> {
const feature = getFeature(id);
const limit = await getFeatureLimit(feature);
const isAllowed = await limit.isAllowed(value || (await feature.used?.()));
return {
id,
isAllowed,
availableOn: isAllowed ? undefined : await availableOn(id, value),
caption: limit.caption,
error: features[id].error(limit)
};
}
export async function getFeatureLimit<TId extends FeatureId>(
feature: Feature<TId>
) {
const plan = await getUserPlan();
return getFeatureLimitFromPlan(feature, plan);
}
export async function areFeaturesAvailable<TIds extends FeatureId[]>(
ids: TIds,
values: number[] = []
): Promise<{
[K in TIds[number]]: FeatureResult<K>;
}> {
const plan = await getUserPlan();
const results = {} as {
[K in TIds[number]]: FeatureResult<K>;
};
for (let i = 0; i < ids.length; ++i) {
const value = values.at(i);
const id = ids[i];
const feature = getFeature(id);
const limit = getFeatureLimitFromPlan(feature, plan);
const isAllowed = await limit.isAllowed(value || (await feature.used?.()));
results[id as TIds[number]] = {
id: id as TIds[number],
isAllowed,
availableOn: isAllowed ? undefined : await availableOn(id, value),
caption: limit.caption as Caption<TIds[number]>,
error: features[id].error(limit)
};
}
return results;
}
async function getUserPlan() {
const user = await db.user.getUser();
const plan = user?.subscription?.plan || SubscriptionPlan.FREE;
return plan;
}
async function availableOn(id: FeatureId, value?: number) {
const feature = features[id];
for (const key in feature.availability) {
if (key === "legacyPro") continue;
if (
await feature.availability[
key as keyof typeof feature.availability
].isAllowed(value)
)
return AVAILABILITY_TO_PLAN[key as keyof typeof feature.availability];
}
}
export function getFeature<TId extends FeatureId>(id: TId): Feature<TId> {
return features[id] as unknown as Feature<TId>;
}
export function getFeatureTitle<TId extends FeatureId>(
id: TId | string,
fallbackTitle?: string
): string {
const feature = getFeature(id as FeatureId);
return feature?.title ?? fallbackTitle ?? id;
}
export function planToAvailability(plan: SubscriptionPlan) {
return PLAN_TO_AVAILABILITY[plan];
}
export function getFeaturesTable() {
// Feature FREE ESSENTIAL PRO BELIEVER
const rows: [string, Limit, Limit, Limit, Limit][] = [];
for (const key in features) {
const feature = features[key as FeatureId];
rows.push([
feature.title,
feature.availability.free,
feature.availability.essential,
feature.availability.pro,
feature.availability.believer
]);
}
return rows;
}
export type FeatureUsage = {
id: FeatureId;
total: number;
used: number;
};
export async function getFeaturesUsage(): Promise<FeatureUsage[]> {
const plan = await getUserPlan();
const usage: FeatureUsage[] = [];
for (const key in features) {
const feature = getFeature(key as FeatureId);
const limit = getFeatureLimitFromPlan(feature, plan);
if (!feature.used || typeof limit.value !== "number") continue;
usage.push({
id: key as FeatureId,
total: limit.value,
used: await feature.used()
});
}
return usage;
}
function getFeatureLimitFromPlan<TId extends FeatureId>(
feature: Feature<TId>,
plan: SubscriptionPlan
): Limit<Caption<TId>> {
const key = PLAN_TO_AVAILABILITY[plan];
return feature.availability[key] as unknown as Limit<Caption<TId>>;
}
const PLAN_TO_AVAILABILITY: Record<
SubscriptionPlan,
keyof Feature["availability"]
> = {
[SubscriptionPlan.FREE]: "free",
[SubscriptionPlan.ESSENTIAL]: "essential",
[SubscriptionPlan.PRO]: "pro",
[SubscriptionPlan.BELIEVER]: "believer",
[SubscriptionPlan.EDUCATION]: "pro",
[SubscriptionPlan.LEGACY_PRO]: "legacyPro"
};
const AVAILABILITY_TO_PLAN: Record<
keyof Feature["availability"],
SubscriptionPlan | undefined
> = {
free: SubscriptionPlan.FREE,
essential: SubscriptionPlan.ESSENTIAL,
pro: SubscriptionPlan.PRO,
believer: SubscriptionPlan.BELIEVER,
legacyPro: undefined
};
function lt(limit: number) {
return async (value?: number) => {
if (typeof value === "undefined") return false;
return value < limit;
};
}
function alwaysTrue() {
return true;
}
function alwaysFalse() {
return false;
}
function alwaysInfinite() {
return true;
}