Chore: Upgrade to AIK & Massive Overhaul to internal processing #78
|
|
@ -44,19 +44,18 @@ export default defineIntegration({
|
||||||
|
|
|||||||
// Configure Loggers
|
// Configure Loggers
|
||||||
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
|
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
|
||||||
|
|
||||||
|
const loggerTagged = (message: 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");
```
|
|||||||
|
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
|
||||||
```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");
```
|
|||||||
// Configure ENV Logger
|
// Configure ENV Logger
|
||||||
const GhostENVLogger = logger.fork(
|
const GhostENVLogger = loggerTagged("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");
```
```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");
```
|
|||||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(
|
|
||||||
```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");
```
|
|||||||
"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");
```
|
|||||||
)}`,
|
|
||||||
```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");
```
|
|||||||
|
|
||||||
// Configure Integration Loggers & verbose logging
|
// Configure Integration Loggers & verbose logging
|
||||||
const GhostIntegrationLogger = logger.fork(
|
const GhostIntegrationLogger = loggerTagged("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");
```
```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");
```
|
|||||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(
|
|
||||||
```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");
```
|
|||||||
"Integrations",
|
// Configure Route Logger & verbose logging
|
||||||
```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");
```
|
|||||||
)}`,
|
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");
```
|
|||||||
|
|
||||||
// Log Info Helper
|
// Log Info Helper
|
||||||
const intLogInfo = (message:string) => {
|
const intLogInfo = (message:string) => {
|
||||||
|
|
@ -65,13 +64,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");
```
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
// Configure Route Logger & verbose logging
|
|
||||||
```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 GhostRouteLogger = logger.fork(
|
|
||||||
```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");
```
|
|||||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(
|
|
||||||
```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");
```
|
|||||||
"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");
```
|
|||||||
|
|
||||||
```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
|
// Log Route Info Helper
|
||||||
const routeLogInfo = (message:string) => {
|
const routeLogInfo = (message:string) => {
|
||||||
if (verbose) {
|
if (verbose) {
|
||||||
|
|
@ -241,17 +233,13 @@ export default defineIntegration({
|
||||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
|||||||
);
|
);
|
||||||
},
|
},
|
||||||
"astro:server:start": async ({ logger }) => {
|
"astro:server:start": async ({ logger }) => {
|
||||||
|
const loggerTagged = (message: 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");
```
|
|||||||
|
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.green(message)}`)
|
||||||
```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");
```
|
|||||||
// Configure Loggers
|
// Configure Loggers
|
||||||
const GhostLogger = logger.fork(
|
const GhostLogger = loggerTagged("DEV");
|
||||||
```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");
```
|
|||||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.bold(
|
|
||||||
```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");
```
|
|||||||
c.green("DEV"),
|
const GhostUpdateLogger = loggerTagged("VERSION CHECK");
|
||||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
```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");
```
|
|||||||
const GhostUpdateLogger = logger.fork(
|
|
||||||
```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");
```
|
|||||||
`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.bold(
|
|
||||||
```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");
```
|
|||||||
c.green("VERSION CHECK"),
|
|
||||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
|||||||
)}`,
|
|
||||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
|||||||
);
|
|
||||||
```suggestion
} else if (verbose) {
GhostIntegrationLogger.info(c.gray("Theme Provider is disabled"));
}
```
same here same here
same here same here
same here same here
is there a reason for not importing it at the top of the file? if yes, I think you can use is there a reason for not importing it at the top of the file? if yes, I think you can use `resolve` from `createResolver` for the path
This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D This is simply to display any new version during dev-mode only... There is a check for latest version and it compares the local version :D
ah this pulls the version from the user's project? ah this pulls the version from the user's project?
I ALWAYS FORGET YOU CAN DO I ALWAYS FORGET YOU CAN DO `else if` vscode should complain if you do an `else { if()` lol
i think if you have eslint you can enable such a rule i think if you have eslint you can enable such a rule
grabs the current installed one from grabs the current installed one from `astro-ghostcms` local version and compares to the latestversion from NPM :P I did actually try to use the `resolve()` util but that just grabbed the playgrounds package.json ironically...
Instead of all these manual checks for Or could be a Florian special and return a console log function: Instead of all these manual checks for `verbose` you'd probably be better off with a util function which checks it instead.
```ts
const log = message => {
if (verbose) {
console.log(...)
}
}
```
Or could be a Florian special and return a console log function:
```ts
const createLogger = verbose => message => {
if (verbose) {
console.log(...)
}
}
const log = createLogger(options.verbose)
log(whatever) // now you don't have to check everywhere
```
added in new commit, since im not using console.log had to modify it for my usage a little added in new commit, since im not using console.log had to modify it for my usage a little
Okay i fixed that issue. Now using Okay i fixed that issue. Now using `resolve()` properly 😄
This logging function could also be extracted This logging function could also be extracted
```ts
const formattedMessage = message => `${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`
```
Updated... Updated...
```ts
// Configure Loggers
const GhostLogger = logger.fork(c.bold(c.blue("👻 Astro-GhostCMS")));
const loggerTagged = (message: string) => {
return logger.fork(`${c.bold(c.blue("👻 Astro-GhostCMS"))}${c.gray("/")}${c.blue(message)}`)
}
// Configure ENV Logger
const GhostENVLogger = loggerTagged("ENV Check");
// Configure Integration Loggers & verbose logging
const GhostIntegrationLogger = loggerTagged("Integrations");
// Configure Route Logger & verbose logging
const GhostRouteLogger = loggerTagged("Router");
```
|
|||||||
|
|
||||||
// Start the DEV server
|
// Start the DEV server
|
||||||
GhostLogger.info(
|
GhostLogger.info(
|
||||||
|
|
|
||||||
```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...