Chore: Upgrade to AIK & Massive Overhaul to internal processing #78
|
|
@ -16,7 +16,7 @@
|
|||
"test:integration": "pnpm --filter astro-ghostcms test",
|
||||
"test:integration:watch": "pnpm --filter astro-ghostcms test:watch",
|
||||
"test:integration:coverage": "pnpm --filter astro-ghostcms test:coverage",
|
||||
"test:create": "pnpm --filter create-astro-ghostcms test",
|
||||
"test:create-utility": "pnpm --filter create-astro-ghostcms test",
|
||||
"test:starlight": "pnpm --filter starlight-ghostcms test",
|
||||
"test:starlight:watch": "pnpm --filter starlight-ghostcms test:watch",
|
||||
"test:starlight:coverage": "pnpm --filter starlight-ghostcms test:coverage"
|
||||
|
|
@ -24,8 +24,8 @@
|
|||
"devDependencies": {
|
||||
"@biomejs/biome": "1.5.3",
|
||||
"@changesets/cli": "^2.27.1",
|
||||
"vitest": "^1.3.0",
|
||||
"vitest-fetch-mock": "^0.2.2",
|
||||
"@vitest/ui": "1.3.0"
|
||||
"@vitest/ui": "^1.3.1",
|
||||
"vitest": "^1.3.1",
|
||||
"vitest-fetch-mock": "^0.2.2"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,9 @@
|
|||
"astro": "^4.4.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"vitest": "^1.3.0",
|
||||
"@types/fs-extra": "11.0.4",
|
||||
"@types/node": "20.11.24",
|
||||
"vitest": "^1.3.1",
|
||||
"vitest-fetch-mock": "^0.2.2"
|
||||
},
|
||||
"dependencies": {
|
||||
|
|
@ -70,6 +72,8 @@
|
|||
"@ts-ghost/content-api": "^4.0.12",
|
||||
"astro-integration-kit": "^0.5.0",
|
||||
"astro-robots-txt": "^1.0.0",
|
||||
"fs-extra": "11.2.0",
|
||||
"package-json": "10.0.0",
|
||||
"picocolors": "1.0.0",
|
||||
"satori": "^0.10.13",
|
||||
"satori-html": "0.3.2",
|
||||
|
|
|
|||
|
|
@ -4,6 +4,9 @@ import { GhostUserConfigSchema } from "./schemas/userconfig";
|
|||
|
|
||||
import { loadEnv } from "vite";
|
||||
import { AstroError } from "astro/errors";
|
||||
import c from "picocolors";
|
||||
import path from "node:path";
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
import { fileURLToPath } from "node:url";
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
import fse from "fs-extra";
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
// Import External Integrations
|
||||
import sitemap from "@astrojs/sitemap";
|
||||
|
|
@ -13,6 +16,7 @@ import robotsTxt from "astro-robots-txt";
|
|||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
import ghostOGImages from "./integrations/satoriog"
|
||||
import ghostRSS from "./integrations/rssfeed"
|
||||
import ghostThemeProvider from "./integrations/themeprovider"
|
||||
import latestVersion from "./utils/latestVersion";
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
// Load environment variables
|
||||
const ENV = loadEnv("all", process.cwd(), "CONTENT_API");
|
||||
|
|
@ -154,16 +158,32 @@ export default defineIntegration({
|
|||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
},
|
||||
"astro:config:done": ({ logger }) => {
|
||||
const GhostLogger = logger.fork(`${c.bold(c.blue('👻 Astro-GhostCMS'))}${c.gray("/")}${c.green('Config')}`);
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const GhostLogger = logger.fork(`${c.bold(c.blue('👻 Astro-GhostCMS'))}${c.gray("/")}${c.green('CONFIG')}`);
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
GhostLogger.info(c.bold(c.green('Integration Setup & Configuration Complete')))
|
||||
},
|
||||
"astro:server:start": ({ logger }) => {
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
"astro:server:start": async ({ logger }) => {
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const GhostLogger = logger.fork(`${c.bold(c.blue('👻 Astro-GhostCMS'))}${c.gray("/")}${c.bold(c.green('DEV'))}`);
|
||||
GhostLogger.info(c.bold(c.magenta('Running Astro-GhostCMS in Deveopment mode')))
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const GhostUpdateLogger = logger.fork(`${c.bold(c.blue('👻 Astro-GhostCMS'))}${c.gray("/")}${c.bold(c.green('VERSION CHECK'))}`);
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const verbose = options.fullConsoleLogs;
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
// Start the DEV server
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
GhostLogger.info(c.bold(c.magenta('Running Astro-GhostCMS in Deveopment mode 🚀')))
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
// Check for updates
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const currentNPMVersion = await latestVersion("@matthiesenxyz/astro-ghostcms");
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const packageJson = await fse.readJson(path.resolve(fileURLToPath(import.meta.url), "../../package.json"));
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
const localVersion = packageJson.version;
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
if (currentNPMVersion !== localVersion) {
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
GhostUpdateLogger.warn(`\n${c.bgYellow(c.bold(c.black(" There is a new version of Astro-GhostCMS available! ")))}\n${c.bold(c.white(" Current Installed Version: ")) + c.bold(c.red(`${localVersion} `))} \n ${c.bold(c.white("New Available Version: "))} ${c.green(currentNPMVersion)} \n ${c.bold(c.white("Please consider updating to the latest version by running: "))} ${c.bold(c.green("npm i @matthiesenxyz/astro-ghostcms@latest"))} \n`)
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
} else {
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
GhostUpdateLogger.info(c.bold(c.green(`Astro-GhostCMS is up to date! v${localVersion}`)))
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
}
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
},
|
||||
"astro:build:done": ({ logger }) => {
|
||||
const GhostLogger = logger.fork(`${c.bold(c.blue('👻 Astro-GhostCMS'))}${c.gray("/")}${c.bold(c.green('BUILD'))}`);
|
||||
GhostLogger.info(c.bold(c.magenta('Running Astro-GhostCMS in Production mode')))
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
GhostLogger.info(c.bold(c.magenta('Running Astro-GhostCMS in Production mode 🚀')))
|
||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
import packageJson from "package-json";
|
||||
|
||||
export type Options = {
|
||||
/**
|
||||
A semver range or [dist-tag](https://docs.npmjs.com/cli/dist-tag).
|
||||
*/
|
||||
readonly version?: string;
|
||||
};
|
||||
|
||||
/**
|
||||
Get the latest version of an npm package.
|
||||
|
||||
@example
|
||||
```
|
||||
console.log(await latestVersion('ava'));
|
||||
//=> '0.18.0'
|
||||
```
|
||||
*/
|
||||
export default async function latestVersion(
|
||||
packageName: string,
|
||||
options?: Options,
|
||||
) {
|
||||
const { version } = await packageJson(packageName.toLowerCase(), options);
|
||||
|
||||
return version;
|
||||
}
|
||||
|
|
@ -46,17 +46,7 @@
|
|||
"@types/gunzip-maybe": "^1.4.0",
|
||||
"@types/node": "^20.11.19",
|
||||
"@types/tar-fs": "^2.0.1",
|
||||
"@typescript-eslint/eslint-plugin": "^7.0.1",
|
||||
"@typescript-eslint/parser": "^7.0.1",
|
||||
"eslint": "^8.56.0",
|
||||
"eslint-config-prettier": "^9.1.0",
|
||||
"eslint-import-resolver-node": "^0.3.7",
|
||||
"eslint-import-resolver-typescript": "^3.5.3",
|
||||
"prettier": "^3.2.5",
|
||||
"typescript": "^5.3.3",
|
||||
"vitest": "^1.3.0",
|
||||
"vite": "^5.1.3",
|
||||
"vite-tsconfig-paths": "^4.2.2"
|
||||
"typescript": "^5.3.3"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
|
|
|
|||
same here
same here
same here
same here
same here
same here
is there a reason for not importing it at the top of the file? if yes, I think you can use
resolvefromcreateResolverfor the pathis there a reason for not importing it at the top of the file? if yes, I think you can use
resolvefromcreateResolverfor the pathThis is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project?
ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO
else ifvscode should complain if you do anelse { if()lolI ALWAYS FORGET YOU CAN DO
else ifvscode should complain if you do anelse { if()loli think if you have eslint you can enable such a rule
i think if you have eslint you can enable such a rule
grabs the current installed one from
astro-ghostcmslocal version and compares to the latestversion from NPM :P I did actually try to use theresolve()util but that just grabbed the playgrounds package.json ironically...grabs the current installed one from
astro-ghostcmslocal version and compares to the latestversion from NPM :P I did actually try to use theresolve()util but that just grabbed the playgrounds package.json ironically...Instead of all these manual checks for
verboseyou'd probably be better off with a util function which checks it instead.Or could be a Florian special and return a console log function:
Instead of all these manual checks for
verboseyou'd probably be better off with a util function which checks it instead.Or could be a Florian special and return a console log function:
added in new commit, since im not using console.log had to modify it for my usage a little
added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using
resolve()properly 😄Okay i fixed that issue. Now using
resolve()properly 😄This logging function could also be extracted
This logging function could also be extracted
Updated...
Updated...