Chore: Upgrade to AIK & Massive Overhaul to internal processing #78
|
|
@ -56,6 +56,9 @@
|
|||
"test:coverage": "vitest run --coverage",
|
||||
"test:ci": "vitest run --coverage.enabled --coverage.reporter='text-summary'"
|
||||
},
|
||||
"enginesStrict": {
|
||||
"node": ">=18.19.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"astro": ">=4.4.1"
|
||||
},
|
||||
|
|
|
|||
|
|
@ -50,19 +50,25 @@ export default defineIntegration({
|
|||
|
|
||||
}) => {
|
||||
// Set up verbose logging
|
||||
const verbose = options.verbose;
|
||||
|
||||
```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");
```
|
||||
// Configure Loggers
|
||||
const GhostLogger = logger.fork(c.bold(c.blue("👻 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");
```
|
||||
// Configure ENV 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 GhostENVLogger = logger.fork(
|
||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(
|
||||
"ENV 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");
```
|
||||
// Configure Integration Loggers & verbose logging
|
||||
const GhostIntegrationLogger = logger.fork(
|
||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(
|
||||
"Integrations",
|
||||
)}`,
|
||||
);
|
||||
|
||||
```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");
```
|
||||
// Log Info Helper
|
||||
```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 intLogInfo = (message:string) => {
|
||||
if (verbose) {
|
||||
GhostIntegrationLogger.info(message);
|
||||
|
|
@ -75,12 +81,46 @@ 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");
```
|
||||
"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");
```
|
||||
// Log Route Info Helper
|
||||
```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 routeLogInfo = (message:string) => {
|
||||
if (verbose) {
|
||||
GhostRouteLogger.info(message);
|
||||
}
|
||||
};
|
||||
|
||||
// Local Integration Helper
|
||||
```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 localIntegration = (enabled: boolean, name: string, integration: AstroIntegration) => {
|
||||
```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 (enabled) {
|
||||
```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");
```
|
||||
addIntegration(integration);
|
||||
```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");
```
|
||||
intLogInfo(c.gray(`${name} integration 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
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");
```
|
||||
|
||||
```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 External Integration Helper
|
||||
```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 checkIntegration = (name: string, integration: AstroIntegration) => {
|
||||
```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 (!hasIntegration(name)) {
|
||||
```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");
```
|
||||
intLogInfo(c.bold(c.magenta(`Adding ${c.blue(name)} integration`)));
|
||||
```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");
```
|
||||
addIntegration(integration);
|
||||
```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");
```
|
||||
intLogInfo(c.gray(`${name} integration already exists, skipping...`));
|
||||
```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");
```
|
||||
|
||||
```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");
```
|
||||
// Inject Route Helper
|
||||
```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 routeHelper = (routename: string, enabled: boolean, pattern: string, entrypoint: string) => {
|
||||
```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 (enabled) {
|
||||
```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");
```
|
||||
routeLogInfo(c.bold(c.cyan(`Setting up ${routename} route`)));
|
||||
```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");
```
|
||||
injectRoute({
|
||||
```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");
```
|
||||
pattern: pattern,
|
||||
```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");
```
|
||||
entrypoint: `${name}${entrypoint}`,
|
||||
```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");
```
|
||||
prerender: true,
|
||||
```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");
```
|
||||
} 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");
```
|
||||
routeLogInfo(c.gray(`${routename} route is disabled, Skipping...`));
|
||||
```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");
```
|
||||
|
||||
// Setup Watch Integration for Hot Reload during DEV
|
||||
watchIntegration(resolve());
|
||||
|
|
@ -143,39 +183,6 @@ 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");
```
|
||||
c.bold(c.magenta("Configuring Enabled Integrations")),
|
||||
);
|
||||
|
||||
// Local Integration Helper
|
||||
```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 localIntegration = (enabled: boolean, name: string, integration: AstroIntegration) => {
|
||||
```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 (enabled) {
|
||||
```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");
```
|
||||
addIntegration(integration);
|
||||
```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");
```
|
||||
intLogInfo(c.gray(`${name} integration 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
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");
```
|
||||
|
||||
```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 External Integration Helper
|
||||
```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 checkIntegration = (name: string, integration: AstroIntegration) => {
|
||||
```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 (!hasIntegration(name)) {
|
||||
```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");
```
|
||||
intLogInfo(c.bold(c.magenta(`Adding ${c.blue(name)} integration`)));
|
||||
```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");
```
|
||||
addIntegration(integration);
|
||||
```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");
```
|
||||
intLogInfo(c.gray(`${name} integration already exists, skipping...`));
|
||||
```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");
```
|
||||
|
||||
```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");
```
|
||||
// Inject Route Helper
|
||||
```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 routeHelper = (routename: string, enabled: boolean, pattern: string, entrypoint: string) => {
|
||||
```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 (enabled) {
|
||||
```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");
```
|
||||
routeLogInfo(c.bold(c.cyan(`Setting up ${routename} route`)));
|
||||
```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");
```
|
||||
injectRoute({
|
||||
```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");
```
|
||||
pattern: pattern,
|
||||
```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");
```
|
||||
entrypoint: `${name}${entrypoint}`,
|
||||
```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");
```
|
||||
prerender: true,
|
||||
```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");
```
|
||||
} 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");
```
|
||||
routeLogInfo(c.gray(`${routename} route is disabled, Skipping...`));
|
||||
```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");
```
|
||||
|
||||
```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");
```
|
||||
localIntegration(
|
||||
!options.ThemeProvider?.disableThemeProvider,
|
||||
"Theme Provider",
|
||||
|
|
|
|||
```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");
```
|
||||
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...