chamomind/elearning
7
0
Fork 0
Code Issues 4 Pull requests Projects Releases Packages 3 Wiki Activity Actions

Website Structure

Browse source
This commit is contained in:
supalerk-ar66 2026-01-13 10:46:40 +07:00
parent 62812f2090
commit 71f0676a62
22365 changed files with 4265753 additions and 791 deletions
Download patch file Download diff file Expand all files Collapse all files

24
Fontend-Learner/.gitignore vendored
View file

@ -1,24 +0,0 @@
# Nuxt dev/build outputs
.output
.data
.nuxt
.nitro
.cache
dist
# Node dependencies
node_modules
# Logs
logs
*.log
# Misc
.DS_Store
.fleet
.idea
# Local env files
.env
.env.*
!.env.example

75
Fontend-Learner/README.md
View file

@ -1,75 +0,0 @@
# Nuxt Minimal Starter
Look at the [Nuxt documentation](https://nuxt.com/docs/getting-started/introduction) to learn more.
## Setup
Make sure to install dependencies:
```bash
# npm
npm install
# pnpm
pnpm install
# yarn
yarn install
# bun
bun install
```
## Development Server
Start the development server on `http://localhost:3000`:
```bash
# npm
npm run dev
# pnpm
pnpm dev
# yarn
yarn dev
# bun
bun run dev
```
## Production
Build the application for production:
```bash
# npm
npm run build
# pnpm
pnpm build
# yarn
yarn build
# bun
bun run build
```
Locally preview production build:
```bash
# npm
npm run preview
# pnpm
pnpm preview
# yarn
yarn preview
# bun
bun run preview
```
Check out the [deployment documentation](https://nuxt.com/docs/getting-started/deployment) for more information.

5
Fontend-Learner/nuxt.config.ts
View file

@ -1,5 +0,0 @@
// https://nuxt.com/docs/api/configuration/nuxt-config
export default defineNuxtConfig({
compatibilityDate: '2025-07-15',
devtools: { enabled: true }
})

17
Fontend-Learner/package.json
View file

@ -1,17 +0,0 @@
{
"name": "Fontend-Learner",
"type": "module",
"private": true,
"scripts": {
"build": "nuxt build",
"dev": "nuxt dev",
"generate": "nuxt generate",
"preview": "nuxt preview",
"postinstall": "nuxt prepare"
},
"dependencies": {
"nuxt": "^4.2.2",
"vue": "^3.5.26",
"vue-router": "^4.6.4"
}
}

BIN
Fontend-Learner/public/favicon.ico
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 4.2 KiB

2
Fontend-Learner/public/robots.txt
View file

@ -1,2 +0,0 @@
User-Agent: *
Disallow:

18
Fontend-Learner/tsconfig.json
View file

@ -1,18 +0,0 @@
{
// https://nuxt.com/docs/guide/concepts/typescript
"files": [],
"references": [
{
"path": "./.nuxt/tsconfig.app.json"
},
{
"path": "./.nuxt/tsconfig.server.json"
},
{
"path": "./.nuxt/tsconfig.shared.json"
},
{
"path": "./.nuxt/tsconfig.node.json"
}
]
}

18
Frontend-Learner/.nuxt/app.config.mjs Normal file
View file

@ -0,0 +1,18 @@
import { _replaceAppConfig } from '#app/config'
import { defuFn } from 'defu'
const inlineConfig = {
"nuxt": {}
}
// Vite - webpack is handled directly in #app/config
if (import.meta.hot) {
import.meta.hot.accept((newModule) => {
_replaceAppConfig(newModule.default)
})
}
export default /*@__PURE__*/ defuFn(inlineConfig)

330
Frontend-Learner/.nuxt/components.d.ts vendored Normal file
View file

@ -0,0 +1,330 @@
import type { DefineComponent, SlotsType } from 'vue'
type IslandComponent<T> = DefineComponent<{}, {refresh: () => Promise<void>}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, SlotsType<{ fallback: { error: unknown } }>> & T
type HydrationStrategies = {
hydrateOnVisible?: IntersectionObserverInit | true
hydrateOnIdle?: number | true
hydrateOnInteraction?: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap> | true
hydrateOnMediaQuery?: string
hydrateAfter?: number
hydrateWhen?: boolean
hydrateNever?: true
}
type LazyComponent<T> = DefineComponent<HydrationStrategies, {}, {}, {}, {}, {}, {}, { hydrated: () => void }> & T
export const AppHeader: typeof import("../components/common/AppHeader.vue").default
export const FormInput: typeof import("../components/common/FormInput.vue").default
export const LandingFooter: typeof import("../components/common/LandingFooter.vue").default
export const LandingHeader: typeof import("../components/common/LandingHeader.vue").default
export const LoadingSkeleton: typeof import("../components/common/LoadingSkeleton.vue").default
export const LoadingSpinner: typeof import("../components/common/LoadingSpinner.vue").default
export const MobileNav: typeof import("../components/common/MobileNav.vue").default
export const CourseCard: typeof import("../components/course/CourseCard.vue").default
export const UserAvatar: typeof import("../components/user/UserAvatar.vue").default
export const UserMenu: typeof import("../components/user/UserMenu.vue").default
export const NuxtWelcome: typeof import("../node_modules/nuxt/dist/app/components/welcome.vue").default
export const NuxtLayout: typeof import("../node_modules/nuxt/dist/app/components/nuxt-layout").default
export const NuxtErrorBoundary: typeof import("../node_modules/nuxt/dist/app/components/nuxt-error-boundary.vue").default
export const ClientOnly: typeof import("../node_modules/nuxt/dist/app/components/client-only").default
export const DevOnly: typeof import("../node_modules/nuxt/dist/app/components/dev-only").default
export const ServerPlaceholder: typeof import("../node_modules/nuxt/dist/app/components/server-placeholder").default
export const NuxtLink: typeof import("../node_modules/nuxt/dist/app/components/nuxt-link").default
export const NuxtLoadingIndicator: typeof import("../node_modules/nuxt/dist/app/components/nuxt-loading-indicator").default
export const NuxtTime: typeof import("../node_modules/nuxt/dist/app/components/nuxt-time.vue").default
export const NuxtRouteAnnouncer: typeof import("../node_modules/nuxt/dist/app/components/nuxt-route-announcer").default
export const NuxtImg: typeof import("../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtImg
export const NuxtPicture: typeof import("../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtPicture
export const QAjaxBar: typeof import("quasar").QAjaxBar
export const QAvatar: typeof import("quasar").QAvatar
export const QBadge: typeof import("quasar").QBadge
export const QBanner: typeof import("quasar").QBanner
export const QBar: typeof import("quasar").QBar
export const QBreadcrumbs: typeof import("quasar").QBreadcrumbs
export const QBreadcrumbsEl: typeof import("quasar").QBreadcrumbsEl
export const QBtn: typeof import("quasar").QBtn
export const QBtnDropdown: typeof import("quasar").QBtnDropdown
export const QBtnGroup: typeof import("quasar").QBtnGroup
export const QBtnToggle: typeof import("quasar").QBtnToggle
export const QCard: typeof import("quasar").QCard
export const QCardActions: typeof import("quasar").QCardActions
export const QCardSection: typeof import("quasar").QCardSection
export const QCarousel: typeof import("quasar").QCarousel
export const QCarouselControl: typeof import("quasar").QCarouselControl
export const QCarouselSlide: typeof import("quasar").QCarouselSlide
export const QChatMessage: typeof import("quasar").QChatMessage
export const QCheckbox: typeof import("quasar").QCheckbox
export const QChip: typeof import("quasar").QChip
export const QCircularProgress: typeof import("quasar").QCircularProgress
export const QColor: typeof import("quasar").QColor
export const QDate: typeof import("quasar").QDate
export const QDialog: typeof import("quasar").QDialog
export const QDrawer: typeof import("quasar").QDrawer
export const QEditor: typeof import("quasar").QEditor
export const QExpansionItem: typeof import("quasar").QExpansionItem
export const QFab: typeof import("quasar").QFab
export const QFabAction: typeof import("quasar").QFabAction
export const QField: typeof import("quasar").QField
export const QFile: typeof import("quasar").QFile
export const QFooter: typeof import("quasar").QFooter
export const QForm: typeof import("quasar").QForm
export const QFormChildMixin: typeof import("quasar").QFormChildMixin
export const QHeader: typeof import("quasar").QHeader
export const QIcon: typeof import("quasar").QIcon
export const QImg: typeof import("quasar").QImg
export const QInfiniteScroll: typeof import("quasar").QInfiniteScroll
export const QInnerLoading: typeof import("quasar").QInnerLoading
export const QInput: typeof import("quasar").QInput
export const QIntersection: typeof import("quasar").QIntersection
export const QItem: typeof import("quasar").QItem
export const QItemLabel: typeof import("quasar").QItemLabel
export const QItemSection: typeof import("quasar").QItemSection
export const QList: typeof import("quasar").QList
export const QKnob: typeof import("quasar").QKnob
export const QLayout: typeof import("quasar").QLayout
export const QLinearProgress: typeof import("quasar").QLinearProgress
export const QMarkupTable: typeof import("quasar").QMarkupTable
export const QMenu: typeof import("quasar").QMenu
export const QNoSsr: typeof import("quasar").QNoSsr
export const QOptionGroup: typeof import("quasar").QOptionGroup
export const QPage: typeof import("quasar").QPage
export const QPageContainer: typeof import("quasar").QPageContainer
export const QPageScroller: typeof import("quasar").QPageScroller
export const QPageSticky: typeof import("quasar").QPageSticky
export const QPagination: typeof import("quasar").QPagination
export const QParallax: typeof import("quasar").QParallax
export const QPopupEdit: typeof import("quasar").QPopupEdit
export const QPopupProxy: typeof import("quasar").QPopupProxy
export const QPullToRefresh: typeof import("quasar").QPullToRefresh
export const QRadio: typeof import("quasar").QRadio
export const QRange: typeof import("quasar").QRange
export const QRating: typeof import("quasar").QRating
export const QResizeObserver: typeof import("quasar").QResizeObserver
export const QResponsive: typeof import("quasar").QResponsive
export const QScrollArea: typeof import("quasar").QScrollArea
export const QScrollObserver: typeof import("quasar").QScrollObserver
export const QSelect: typeof import("quasar").QSelect
export const QSeparator: typeof import("quasar").QSeparator
export const QSkeleton: typeof import("quasar").QSkeleton
export const QSlideItem: typeof import("quasar").QSlideItem
export const QSlideTransition: typeof import("quasar").QSlideTransition
export const QSlider: typeof import("quasar").QSlider
export const QSpace: typeof import("quasar").QSpace
export const QSpinner: typeof import("quasar").QSpinner
export const QSpinnerAudio: typeof import("quasar").QSpinnerAudio
export const QSpinnerBall: typeof import("quasar").QSpinnerBall
export const QSpinnerBars: typeof import("quasar").QSpinnerBars
export const QSpinnerBox: typeof import("quasar").QSpinnerBox
export const QSpinnerClock: typeof import("quasar").QSpinnerClock
export const QSpinnerComment: typeof import("quasar").QSpinnerComment
export const QSpinnerCube: typeof import("quasar").QSpinnerCube
export const QSpinnerDots: typeof import("quasar").QSpinnerDots
export const QSpinnerFacebook: typeof import("quasar").QSpinnerFacebook
export const QSpinnerGears: typeof import("quasar").QSpinnerGears
export const QSpinnerGrid: typeof import("quasar").QSpinnerGrid
export const QSpinnerHearts: typeof import("quasar").QSpinnerHearts
export const QSpinnerHourglass: typeof import("quasar").QSpinnerHourglass
export const QSpinnerInfinity: typeof import("quasar").QSpinnerInfinity
export const QSpinnerIos: typeof import("quasar").QSpinnerIos
export const QSpinnerOrbit: typeof import("quasar").QSpinnerOrbit
export const QSpinnerOval: typeof import("quasar").QSpinnerOval
export const QSpinnerPie: typeof import("quasar").QSpinnerPie
export const QSpinnerPuff: typeof import("quasar").QSpinnerPuff
export const QSpinnerRadio: typeof import("quasar").QSpinnerRadio
export const QSpinnerRings: typeof import("quasar").QSpinnerRings
export const QSpinnerTail: typeof import("quasar").QSpinnerTail
export const QSplitter: typeof import("quasar").QSplitter
export const QStep: typeof import("quasar").QStep
export const QStepper: typeof import("quasar").QStepper
export const QStepperNavigation: typeof import("quasar").QStepperNavigation
export const QTabPanel: typeof import("quasar").QTabPanel
export const QTabPanels: typeof import("quasar").QTabPanels
export const QTable: typeof import("quasar").QTable
export const QTd: typeof import("quasar").QTd
export const QTh: typeof import("quasar").QTh
export const QTr: typeof import("quasar").QTr
export const QRouteTab: typeof import("quasar").QRouteTab
export const QTab: typeof import("quasar").QTab
export const QTabs: typeof import("quasar").QTabs
export const QTime: typeof import("quasar").QTime
export const QTimeline: typeof import("quasar").QTimeline
export const QTimelineEntry: typeof import("quasar").QTimelineEntry
export const QToggle: typeof import("quasar").QToggle
export const QToolbar: typeof import("quasar").QToolbar
export const QToolbarTitle: typeof import("quasar").QToolbarTitle
export const QTooltip: typeof import("quasar").QTooltip
export const QTree: typeof import("quasar").QTree
export const QUploader: typeof import("quasar").QUploader
export const QUploaderAddTrigger: typeof import("quasar").QUploaderAddTrigger
export const QVideo: typeof import("quasar").QVideo
export const QVirtualScroll: typeof import("quasar").QVirtualScroll
export const NuxtPage: typeof import("../node_modules/nuxt/dist/pages/runtime/page").default
export const NoScript: typeof import("../node_modules/nuxt/dist/head/runtime/components").NoScript
export const Link: typeof import("../node_modules/nuxt/dist/head/runtime/components").Link
export const Base: typeof import("../node_modules/nuxt/dist/head/runtime/components").Base
export const Title: typeof import("../node_modules/nuxt/dist/head/runtime/components").Title
export const Meta: typeof import("../node_modules/nuxt/dist/head/runtime/components").Meta
export const Style: typeof import("../node_modules/nuxt/dist/head/runtime/components").Style
export const Head: typeof import("../node_modules/nuxt/dist/head/runtime/components").Head
export const Html: typeof import("../node_modules/nuxt/dist/head/runtime/components").Html
export const Body: typeof import("../node_modules/nuxt/dist/head/runtime/components").Body
export const NuxtIsland: typeof import("../node_modules/nuxt/dist/app/components/nuxt-island").default
export const LazyAppHeader: LazyComponent<typeof import("../components/common/AppHeader.vue").default>
export const LazyFormInput: LazyComponent<typeof import("../components/common/FormInput.vue").default>
export const LazyLandingFooter: LazyComponent<typeof import("../components/common/LandingFooter.vue").default>
export const LazyLandingHeader: LazyComponent<typeof import("../components/common/LandingHeader.vue").default>
export const LazyLoadingSkeleton: LazyComponent<typeof import("../components/common/LoadingSkeleton.vue").default>
export const LazyLoadingSpinner: LazyComponent<typeof import("../components/common/LoadingSpinner.vue").default>
export const LazyMobileNav: LazyComponent<typeof import("../components/common/MobileNav.vue").default>
export const LazyCourseCard: LazyComponent<typeof import("../components/course/CourseCard.vue").default>
export const LazyUserAvatar: LazyComponent<typeof import("../components/user/UserAvatar.vue").default>
export const LazyUserMenu: LazyComponent<typeof import("../components/user/UserMenu.vue").default>
export const LazyNuxtWelcome: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/welcome.vue").default>
export const LazyNuxtLayout: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-layout").default>
export const LazyNuxtErrorBoundary: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-error-boundary.vue").default>
export const LazyClientOnly: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/client-only").default>
export const LazyDevOnly: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/dev-only").default>
export const LazyServerPlaceholder: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/server-placeholder").default>
export const LazyNuxtLink: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-link").default>
export const LazyNuxtLoadingIndicator: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-loading-indicator").default>
export const LazyNuxtTime: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-time.vue").default>
export const LazyNuxtRouteAnnouncer: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-route-announcer").default>
export const LazyNuxtImg: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtImg>
export const LazyNuxtPicture: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtPicture>
export const LazyQAjaxBar: LazyComponent<typeof import("quasar").QAjaxBar>
export const LazyQAvatar: LazyComponent<typeof import("quasar").QAvatar>
export const LazyQBadge: LazyComponent<typeof import("quasar").QBadge>
export const LazyQBanner: LazyComponent<typeof import("quasar").QBanner>
export const LazyQBar: LazyComponent<typeof import("quasar").QBar>
export const LazyQBreadcrumbs: LazyComponent<typeof import("quasar").QBreadcrumbs>
export const LazyQBreadcrumbsEl: LazyComponent<typeof import("quasar").QBreadcrumbsEl>
export const LazyQBtn: LazyComponent<typeof import("quasar").QBtn>
export const LazyQBtnDropdown: LazyComponent<typeof import("quasar").QBtnDropdown>
export const LazyQBtnGroup: LazyComponent<typeof import("quasar").QBtnGroup>
export const LazyQBtnToggle: LazyComponent<typeof import("quasar").QBtnToggle>
export const LazyQCard: LazyComponent<typeof import("quasar").QCard>
export const LazyQCardActions: LazyComponent<typeof import("quasar").QCardActions>
export const LazyQCardSection: LazyComponent<typeof import("quasar").QCardSection>
export const LazyQCarousel: LazyComponent<typeof import("quasar").QCarousel>
export const LazyQCarouselControl: LazyComponent<typeof import("quasar").QCarouselControl>
export const LazyQCarouselSlide: LazyComponent<typeof import("quasar").QCarouselSlide>
export const LazyQChatMessage: LazyComponent<typeof import("quasar").QChatMessage>
export const LazyQCheckbox: LazyComponent<typeof import("quasar").QCheckbox>
export const LazyQChip: LazyComponent<typeof import("quasar").QChip>
export const LazyQCircularProgress: LazyComponent<typeof import("quasar").QCircularProgress>
export const LazyQColor: LazyComponent<typeof import("quasar").QColor>
export const LazyQDate: LazyComponent<typeof import("quasar").QDate>
export const LazyQDialog: LazyComponent<typeof import("quasar").QDialog>
export const LazyQDrawer: LazyComponent<typeof import("quasar").QDrawer>
export const LazyQEditor: LazyComponent<typeof import("quasar").QEditor>
export const LazyQExpansionItem: LazyComponent<typeof import("quasar").QExpansionItem>
export const LazyQFab: LazyComponent<typeof import("quasar").QFab>
export const LazyQFabAction: LazyComponent<typeof import("quasar").QFabAction>
export const LazyQField: LazyComponent<typeof import("quasar").QField>
export const LazyQFile: LazyComponent<typeof import("quasar").QFile>
export const LazyQFooter: LazyComponent<typeof import("quasar").QFooter>
export const LazyQForm: LazyComponent<typeof import("quasar").QForm>
export const LazyQFormChildMixin: LazyComponent<typeof import("quasar").QFormChildMixin>
export const LazyQHeader: LazyComponent<typeof import("quasar").QHeader>
export const LazyQIcon: LazyComponent<typeof import("quasar").QIcon>
export const LazyQImg: LazyComponent<typeof import("quasar").QImg>
export const LazyQInfiniteScroll: LazyComponent<typeof import("quasar").QInfiniteScroll>
export const LazyQInnerLoading: LazyComponent<typeof import("quasar").QInnerLoading>
export const LazyQInput: LazyComponent<typeof import("quasar").QInput>
export const LazyQIntersection: LazyComponent<typeof import("quasar").QIntersection>
export const LazyQItem: LazyComponent<typeof import("quasar").QItem>
export const LazyQItemLabel: LazyComponent<typeof import("quasar").QItemLabel>
export const LazyQItemSection: LazyComponent<typeof import("quasar").QItemSection>
export const LazyQList: LazyComponent<typeof import("quasar").QList>
export const LazyQKnob: LazyComponent<typeof import("quasar").QKnob>
export const LazyQLayout: LazyComponent<typeof import("quasar").QLayout>
export const LazyQLinearProgress: LazyComponent<typeof import("quasar").QLinearProgress>
export const LazyQMarkupTable: LazyComponent<typeof import("quasar").QMarkupTable>
export const LazyQMenu: LazyComponent<typeof import("quasar").QMenu>
export const LazyQNoSsr: LazyComponent<typeof import("quasar").QNoSsr>
export const LazyQOptionGroup: LazyComponent<typeof import("quasar").QOptionGroup>
export const LazyQPage: LazyComponent<typeof import("quasar").QPage>
export const LazyQPageContainer: LazyComponent<typeof import("quasar").QPageContainer>
export const LazyQPageScroller: LazyComponent<typeof import("quasar").QPageScroller>
export const LazyQPageSticky: LazyComponent<typeof import("quasar").QPageSticky>
export const LazyQPagination: LazyComponent<typeof import("quasar").QPagination>
export const LazyQParallax: LazyComponent<typeof import("quasar").QParallax>
export const LazyQPopupEdit: LazyComponent<typeof import("quasar").QPopupEdit>
export const LazyQPopupProxy: LazyComponent<typeof import("quasar").QPopupProxy>
export const LazyQPullToRefresh: LazyComponent<typeof import("quasar").QPullToRefresh>
export const LazyQRadio: LazyComponent<typeof import("quasar").QRadio>
export const LazyQRange: LazyComponent<typeof import("quasar").QRange>
export const LazyQRating: LazyComponent<typeof import("quasar").QRating>
export const LazyQResizeObserver: LazyComponent<typeof import("quasar").QResizeObserver>
export const LazyQResponsive: LazyComponent<typeof import("quasar").QResponsive>
export const LazyQScrollArea: LazyComponent<typeof import("quasar").QScrollArea>
export const LazyQScrollObserver: LazyComponent<typeof import("quasar").QScrollObserver>
export const LazyQSelect: LazyComponent<typeof import("quasar").QSelect>
export const LazyQSeparator: LazyComponent<typeof import("quasar").QSeparator>
export const LazyQSkeleton: LazyComponent<typeof import("quasar").QSkeleton>
export const LazyQSlideItem: LazyComponent<typeof import("quasar").QSlideItem>
export const LazyQSlideTransition: LazyComponent<typeof import("quasar").QSlideTransition>
export const LazyQSlider: LazyComponent<typeof import("quasar").QSlider>
export const LazyQSpace: LazyComponent<typeof import("quasar").QSpace>
export const LazyQSpinner: LazyComponent<typeof import("quasar").QSpinner>
export const LazyQSpinnerAudio: LazyComponent<typeof import("quasar").QSpinnerAudio>
export const LazyQSpinnerBall: LazyComponent<typeof import("quasar").QSpinnerBall>
export const LazyQSpinnerBars: LazyComponent<typeof import("quasar").QSpinnerBars>
export const LazyQSpinnerBox: LazyComponent<typeof import("quasar").QSpinnerBox>
export const LazyQSpinnerClock: LazyComponent<typeof import("quasar").QSpinnerClock>
export const LazyQSpinnerComment: LazyComponent<typeof import("quasar").QSpinnerComment>
export const LazyQSpinnerCube: LazyComponent<typeof import("quasar").QSpinnerCube>
export const LazyQSpinnerDots: LazyComponent<typeof import("quasar").QSpinnerDots>
export const LazyQSpinnerFacebook: LazyComponent<typeof import("quasar").QSpinnerFacebook>
export const LazyQSpinnerGears: LazyComponent<typeof import("quasar").QSpinnerGears>
export const LazyQSpinnerGrid: LazyComponent<typeof import("quasar").QSpinnerGrid>
export const LazyQSpinnerHearts: LazyComponent<typeof import("quasar").QSpinnerHearts>
export const LazyQSpinnerHourglass: LazyComponent<typeof import("quasar").QSpinnerHourglass>
export const LazyQSpinnerInfinity: LazyComponent<typeof import("quasar").QSpinnerInfinity>
export const LazyQSpinnerIos: LazyComponent<typeof import("quasar").QSpinnerIos>
export const LazyQSpinnerOrbit: LazyComponent<typeof import("quasar").QSpinnerOrbit>
export const LazyQSpinnerOval: LazyComponent<typeof import("quasar").QSpinnerOval>
export const LazyQSpinnerPie: LazyComponent<typeof import("quasar").QSpinnerPie>
export const LazyQSpinnerPuff: LazyComponent<typeof import("quasar").QSpinnerPuff>
export const LazyQSpinnerRadio: LazyComponent<typeof import("quasar").QSpinnerRadio>
export const LazyQSpinnerRings: LazyComponent<typeof import("quasar").QSpinnerRings>
export const LazyQSpinnerTail: LazyComponent<typeof import("quasar").QSpinnerTail>
export const LazyQSplitter: LazyComponent<typeof import("quasar").QSplitter>
export const LazyQStep: LazyComponent<typeof import("quasar").QStep>
export const LazyQStepper: LazyComponent<typeof import("quasar").QStepper>
export const LazyQStepperNavigation: LazyComponent<typeof import("quasar").QStepperNavigation>
export const LazyQTabPanel: LazyComponent<typeof import("quasar").QTabPanel>
export const LazyQTabPanels: LazyComponent<typeof import("quasar").QTabPanels>
export const LazyQTable: LazyComponent<typeof import("quasar").QTable>
export const LazyQTd: LazyComponent<typeof import("quasar").QTd>
export const LazyQTh: LazyComponent<typeof import("quasar").QTh>
export const LazyQTr: LazyComponent<typeof import("quasar").QTr>
export const LazyQRouteTab: LazyComponent<typeof import("quasar").QRouteTab>
export const LazyQTab: LazyComponent<typeof import("quasar").QTab>
export const LazyQTabs: LazyComponent<typeof import("quasar").QTabs>
export const LazyQTime: LazyComponent<typeof import("quasar").QTime>
export const LazyQTimeline: LazyComponent<typeof import("quasar").QTimeline>
export const LazyQTimelineEntry: LazyComponent<typeof import("quasar").QTimelineEntry>
export const LazyQToggle: LazyComponent<typeof import("quasar").QToggle>
export const LazyQToolbar: LazyComponent<typeof import("quasar").QToolbar>
export const LazyQToolbarTitle: LazyComponent<typeof import("quasar").QToolbarTitle>
export const LazyQTooltip: LazyComponent<typeof import("quasar").QTooltip>
export const LazyQTree: LazyComponent<typeof import("quasar").QTree>
export const LazyQUploader: LazyComponent<typeof import("quasar").QUploader>
export const LazyQUploaderAddTrigger: LazyComponent<typeof import("quasar").QUploaderAddTrigger>
export const LazyQVideo: LazyComponent<typeof import("quasar").QVideo>
export const LazyQVirtualScroll: LazyComponent<typeof import("quasar").QVirtualScroll>
export const LazyNuxtPage: LazyComponent<typeof import("../node_modules/nuxt/dist/pages/runtime/page").default>
export const LazyNoScript: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").NoScript>
export const LazyLink: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Link>
export const LazyBase: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Base>
export const LazyTitle: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Title>
export const LazyMeta: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Meta>
export const LazyStyle: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Style>
export const LazyHead: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Head>
export const LazyHtml: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Html>
export const LazyBody: LazyComponent<typeof import("../node_modules/nuxt/dist/head/runtime/components").Body>
export const LazyNuxtIsland: LazyComponent<typeof import("../node_modules/nuxt/dist/app/components/nuxt-island").default>
export const componentNames: string[]

2410
Frontend-Learner/.nuxt/dev/index.mjs Normal file
View file

File diff suppressed because it is too large Load diff

1
Frontend-Learner/.nuxt/dev/index.mjs.map Normal file
View file

File diff suppressed because one or more lines are too long

1
Frontend-Learner/.nuxt/dist/server/client.manifest.mjs vendored Normal file
View file

@ -0,0 +1 @@
export { default } from "file:///C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/vite-builder/dist/runtime/client.manifest.mjs"

1
Frontend-Learner/.nuxt/dist/server/client.precomputed.mjs vendored Normal file
View file

@ -0,0 +1 @@
export default undefined

1
Frontend-Learner/.nuxt/dist/server/server.mjs vendored Normal file
View file

@ -0,0 +1 @@
export { default } from "file:///C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/vite-builder/dist/runtime/vite-node.mjs"

36
Frontend-Learner/.nuxt/imports.d.ts vendored Normal file
View file

@ -0,0 +1,36 @@
export { useScriptTriggerConsent, useScriptEventPage, useScriptTriggerElement, useScript, useScriptGoogleAnalytics, useScriptPlausibleAnalytics, useScriptCrisp, useScriptClarity, useScriptCloudflareWebAnalytics, useScriptFathomAnalytics, useScriptMatomoAnalytics, useScriptGoogleTagManager, useScriptGoogleAdsense, useScriptSegment, useScriptMetaPixel, useScriptXPixel, useScriptIntercom, useScriptHotjar, useScriptStripe, useScriptLemonSqueezy, useScriptVimeoPlayer, useScriptYouTubePlayer, useScriptGoogleMaps, useScriptNpm, useScriptUmamiAnalytics, useScriptSnapchatPixel, useScriptRybbitAnalytics, useScriptDatabuddyAnalytics, useScriptRedditPixel, useScriptPayPal } from '#app/composables/script-stubs';
export { isVue2, isVue3 } from 'vue-demi';
export { defineNuxtLink } from '#app/components/nuxt-link';
export { useNuxtApp, tryUseNuxtApp, defineNuxtPlugin, definePayloadPlugin, useRuntimeConfig, defineAppConfig } from '#app/nuxt';
export { useAppConfig, updateAppConfig } from '#app/config';
export { defineNuxtComponent } from '#app/composables/component';
export { useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData } from '#app/composables/asyncData';
export { useHydration } from '#app/composables/hydrate';
export { callOnce } from '#app/composables/once';
export { useState, clearNuxtState } from '#app/composables/state';
export { clearError, createError, isNuxtError, showError, useError } from '#app/composables/error';
export { useFetch, useLazyFetch } from '#app/composables/fetch';
export { useCookie, refreshCookie } from '#app/composables/cookie';
export { onPrehydrate, prerenderRoutes, useRequestHeader, useRequestHeaders, useResponseHeader, useRequestEvent, useRequestFetch, setResponseStatus } from '#app/composables/ssr';
export { onNuxtReady } from '#app/composables/ready';
export { preloadComponents, prefetchComponents, preloadRouteComponents } from '#app/composables/preload';
export { abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, setPageLayout, navigateTo, useRoute, useRouter } from '#app/composables/router';
export { isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver } from '#app/composables/payload';
export { useLoadingIndicator } from '#app/composables/loading-indicator';
export { getAppManifest, getRouteRules } from '#app/composables/manifest';
export { reloadNuxtApp } from '#app/composables/chunk';
export { useRequestURL } from '#app/composables/url';
export { usePreviewMode } from '#app/composables/preview';
export { useRouteAnnouncer } from '#app/composables/route-announcer';
export { useRuntimeHook } from '#app/composables/runtime-hook';
export { useHead, useHeadSafe, useServerHeadSafe, useServerHead, useSeoMeta, useServerSeoMeta, injectHead } from '#app/composables/head';
export { onBeforeRouteLeave, onBeforeRouteUpdate, useLink } from 'vue-router';
export { withCtx, withDirectives, withKeys, withMemo, withModifiers, withScopeId, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, computed, customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, watch, watchEffect, watchPostEffect, watchSyncEffect, onWatcherCleanup, isShallow, effect, effectScope, getCurrentScope, onScopeDispose, defineComponent, defineAsyncComponent, resolveComponent, getCurrentInstance, h, inject, hasInjectionContext, nextTick, provide, toValue, useModel, useAttrs, useCssModule, useCssVars, useSlots, useTransitionState, useId, useTemplateRef, useShadowRoot, Component, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue';
export { requestIdleCallback, cancelIdleCallback } from '#app/compat/idle-callback';
export { setInterval } from '#app/compat/interval';
export { definePageMeta } from '../node_modules/nuxt/dist/pages/runtime/composables';
export { defineLazyHydrationComponent } from '#app/composables/lazy-hydration';
export { useAuth } from '../composables/useAuth';
export { useFormValidation, ValidationRule, FieldErrors } from '../composables/useFormValidation';
export { useDialogPluginComponent, useFormChild, useInterval, useMeta, useQuasar, useRenderCache, useSplitAttrs, useTick, useTimeout, Notify } from 'quasar';
export { useNuxtDevTools } from '../node_modules/@nuxt/devtools/dist/runtime/use-nuxt-devtools';

1
Frontend-Learner/.nuxt/manifest/latest.json Normal file
View file

@ -0,0 +1 @@
{"id":"dev","timestamp":1768275611480}

1
Frontend-Learner/.nuxt/manifest/meta/dev.json Normal file
View file

@ -0,0 +1 @@
{"id":"dev","timestamp":1768275611480,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}

17
Frontend-Learner/.nuxt/nitro.json Normal file
View file

@ -0,0 +1,17 @@
{
"date": "2026-01-13T03:40:17.768Z",
"preset": "nitro-dev",
"framework": {
"name": "nuxt",
"version": "3.20.2"
},
"versions": {
"nitro": "2.12.8"
},
"dev": {
"pid": 14040,
"workerAddress": {
"socketPath": "\\\\.\\pipe\\nitro-worker-14040-1-1-9354.sock"
}
}
}

25
Frontend-Learner/.nuxt/nuxt.d.ts vendored Normal file
View file

@ -0,0 +1,25 @@
/// <reference types="quasar" />
/// <reference types="nuxt-quasar-ui" />
/// <reference types="@nuxt/telemetry" />
/// <reference types="@nuxtjs/tailwindcss" />
/// <reference types="@nuxt/devtools" />
/// <reference path="types/builder-env.d.ts" />
/// <reference types="nuxt" />
/// <reference path="types/app-defaults.d.ts" />
/// <reference path="types/plugins.d.ts" />
/// <reference path="types/build.d.ts" />
/// <reference path="types/schema.d.ts" />
/// <reference path="types/app.config.d.ts" />
/// <reference types="C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/nitro-server/dist/index.mjs" />
/// <reference path="quasar.shims.d.ts" />
/// <reference types="vue-router" />
/// <reference path="types/middleware.d.ts" />
/// <reference path="types/nitro-middleware.d.ts" />
/// <reference path="types/layouts.d.ts" />
/// <reference path="types/components.d.ts" />
/// <reference path="imports.d.ts" />
/// <reference path="types/imports.d.ts" />
/// <reference path="schema/nuxt.schema.d.ts" />
/// <reference path="types/nitro.d.ts" />
export {}

9
Frontend-Learner/.nuxt/nuxt.json Normal file
View file

@ -0,0 +1,9 @@
{
"_hash": "WzOS3zXJIH1B1GkjupdnkxKrBJTgPadSNx-CHvTdgko",
"project": {
"rootDir": "C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner"
},
"versions": {
"nuxt": "3.20.2"
}
}

16
Frontend-Learner/.nuxt/quasar.config.mjs Normal file
View file

@ -0,0 +1,16 @@
import lang from "quasar/lang/en-US.js"
import iconSet from "quasar/icon-set/material-icons.js"
import { Notify } from "quasar"
export const componentsWithDefaults = { }
export const appConfigKey = "nuxtQuasar"
export const quasarNuxtConfig = {
lang,
iconSet,
components: {"defaults":{},"autoImport":true},
plugins: {Notify},
config: {"brand":{"primary":"#4b82f7","secondary":"#2f5ed7","accent":"#44d4a8","dark":"#0f1827"}}
}

152
Frontend-Learner/.nuxt/quasar.shims.d.ts vendored Normal file
View file

@ -0,0 +1,152 @@
type KeysMatching<T, V> = {
[K in keyof T]-?: T[K] extends V ? K : never
}[keyof T] & keyof T
type OptionalKeys<T extends object> = Exclude<{
[K in keyof T]: T extends Record<K, T[K]> ? never : K
}[keyof T], undefined>
type OmitMatching<T extends object, V> = Omit<T, KeysMatching<T, V>>
type OmitFnProps<T extends object> = OmitMatching<T, ((...args: any[]) => any) | undefined>
type PickOptionalProps<T extends object> = Pick<T, OptionalKeys<T>>
declare module 'nuxt-quasar-ui' {
interface QuasarComponentDefaults {
QAjaxBar?: PickOptionalProps<OmitFnProps<import("quasar").QAjaxBarProps>>
QAvatar?: PickOptionalProps<OmitFnProps<import("quasar").QAvatarProps>>
QBadge?: PickOptionalProps<OmitFnProps<import("quasar").QBadgeProps>>
QBanner?: PickOptionalProps<OmitFnProps<import("quasar").QBannerProps>>
QBar?: PickOptionalProps<OmitFnProps<import("quasar").QBarProps>>
QBreadcrumbs?: PickOptionalProps<OmitFnProps<import("quasar").QBreadcrumbsProps>>
QBreadcrumbsEl?: PickOptionalProps<OmitFnProps<import("quasar").QBreadcrumbsElProps>>
QBtn?: PickOptionalProps<OmitFnProps<import("quasar").QBtnProps>>
QBtnDropdown?: PickOptionalProps<OmitFnProps<import("quasar").QBtnDropdownProps>>
QBtnGroup?: PickOptionalProps<OmitFnProps<import("quasar").QBtnGroupProps>>
QBtnToggle?: PickOptionalProps<OmitFnProps<import("quasar").QBtnToggleProps>>
QCard?: PickOptionalProps<OmitFnProps<import("quasar").QCardProps>>
QCardActions?: PickOptionalProps<OmitFnProps<import("quasar").QCardActionsProps>>
QCardSection?: PickOptionalProps<OmitFnProps<import("quasar").QCardSectionProps>>
QCarousel?: PickOptionalProps<OmitFnProps<import("quasar").QCarouselProps>>
QCarouselControl?: PickOptionalProps<OmitFnProps<import("quasar").QCarouselControlProps>>
QCarouselSlide?: PickOptionalProps<OmitFnProps<import("quasar").QCarouselSlideProps>>
QChatMessage?: PickOptionalProps<OmitFnProps<import("quasar").QChatMessageProps>>
QCheckbox?: PickOptionalProps<OmitFnProps<import("quasar").QCheckboxProps>>
QChip?: PickOptionalProps<OmitFnProps<import("quasar").QChipProps>>
QCircularProgress?: PickOptionalProps<OmitFnProps<import("quasar").QCircularProgressProps>>
QColor?: PickOptionalProps<OmitFnProps<import("quasar").QColorProps>>
QDate?: PickOptionalProps<OmitFnProps<import("quasar").QDateProps>>
QDialog?: PickOptionalProps<OmitFnProps<import("quasar").QDialogProps>>
QDrawer?: PickOptionalProps<OmitFnProps<import("quasar").QDrawerProps>>
QEditor?: PickOptionalProps<OmitFnProps<import("quasar").QEditorProps>>
QExpansionItem?: PickOptionalProps<OmitFnProps<import("quasar").QExpansionItemProps>>
QFab?: PickOptionalProps<OmitFnProps<import("quasar").QFabProps>>
QFabAction?: PickOptionalProps<OmitFnProps<import("quasar").QFabActionProps>>
QField?: PickOptionalProps<OmitFnProps<import("quasar").QFieldProps>>
QFile?: PickOptionalProps<OmitFnProps<import("quasar").QFileProps>>
QFooter?: PickOptionalProps<OmitFnProps<import("quasar").QFooterProps>>
QForm?: PickOptionalProps<OmitFnProps<import("quasar").QFormProps>>
QFormChildMixin?: PickOptionalProps<OmitFnProps<import("quasar").QFormChildMixinProps>>
QHeader?: PickOptionalProps<OmitFnProps<import("quasar").QHeaderProps>>
QIcon?: PickOptionalProps<OmitFnProps<import("quasar").QIconProps>>
QImg?: PickOptionalProps<OmitFnProps<import("quasar").QImgProps>>
QInfiniteScroll?: PickOptionalProps<OmitFnProps<import("quasar").QInfiniteScrollProps>>
QInnerLoading?: PickOptionalProps<OmitFnProps<import("quasar").QInnerLoadingProps>>
QInput?: PickOptionalProps<OmitFnProps<import("quasar").QInputProps>>
QIntersection?: PickOptionalProps<OmitFnProps<import("quasar").QIntersectionProps>>
QItem?: PickOptionalProps<OmitFnProps<import("quasar").QItemProps>>
QItemLabel?: PickOptionalProps<OmitFnProps<import("quasar").QItemLabelProps>>
QItemSection?: PickOptionalProps<OmitFnProps<import("quasar").QItemSectionProps>>
QList?: PickOptionalProps<OmitFnProps<import("quasar").QListProps>>
QKnob?: PickOptionalProps<OmitFnProps<import("quasar").QKnobProps>>
QLayout?: PickOptionalProps<OmitFnProps<import("quasar").QLayoutProps>>
QLinearProgress?: PickOptionalProps<OmitFnProps<import("quasar").QLinearProgressProps>>
QMarkupTable?: PickOptionalProps<OmitFnProps<import("quasar").QMarkupTableProps>>
QMenu?: PickOptionalProps<OmitFnProps<import("quasar").QMenuProps>>
QNoSsr?: PickOptionalProps<OmitFnProps<import("quasar").QNoSsrProps>>
QOptionGroup?: PickOptionalProps<OmitFnProps<import("quasar").QOptionGroupProps>>
QPage?: PickOptionalProps<OmitFnProps<import("quasar").QPageProps>>
QPageContainer?: PickOptionalProps<OmitFnProps<import("quasar").QPageContainerProps>>
QPageScroller?: PickOptionalProps<OmitFnProps<import("quasar").QPageScrollerProps>>
QPageSticky?: PickOptionalProps<OmitFnProps<import("quasar").QPageStickyProps>>
QPagination?: PickOptionalProps<OmitFnProps<import("quasar").QPaginationProps>>
QParallax?: PickOptionalProps<OmitFnProps<import("quasar").QParallaxProps>>
QPopupEdit?: PickOptionalProps<OmitFnProps<import("quasar").QPopupEditProps>>
QPopupProxy?: PickOptionalProps<OmitFnProps<import("quasar").QPopupProxyProps>>
QPullToRefresh?: PickOptionalProps<OmitFnProps<import("quasar").QPullToRefreshProps>>
QRadio?: PickOptionalProps<OmitFnProps<import("quasar").QRadioProps>>
QRange?: PickOptionalProps<OmitFnProps<import("quasar").QRangeProps>>
QRating?: PickOptionalProps<OmitFnProps<import("quasar").QRatingProps>>
QResizeObserver?: PickOptionalProps<OmitFnProps<import("quasar").QResizeObserverProps>>
QResponsive?: PickOptionalProps<OmitFnProps<import("quasar").QResponsiveProps>>
QScrollArea?: PickOptionalProps<OmitFnProps<import("quasar").QScrollAreaProps>>
QScrollObserver?: PickOptionalProps<OmitFnProps<import("quasar").QScrollObserverProps>>
QSelect?: PickOptionalProps<OmitFnProps<import("quasar").QSelectProps>>
QSeparator?: PickOptionalProps<OmitFnProps<import("quasar").QSeparatorProps>>
QSkeleton?: PickOptionalProps<OmitFnProps<import("quasar").QSkeletonProps>>
QSlideItem?: PickOptionalProps<OmitFnProps<import("quasar").QSlideItemProps>>
QSlideTransition?: PickOptionalProps<OmitFnProps<import("quasar").QSlideTransitionProps>>
QSlider?: PickOptionalProps<OmitFnProps<import("quasar").QSliderProps>>
QSpace?: PickOptionalProps<OmitFnProps<import("quasar").QSpaceProps>>
QSpinner?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerProps>>
QSpinnerAudio?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerAudioProps>>
QSpinnerBall?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerBallProps>>
QSpinnerBars?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerBarsProps>>
QSpinnerBox?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerBoxProps>>
QSpinnerClock?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerClockProps>>
QSpinnerComment?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerCommentProps>>
QSpinnerCube?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerCubeProps>>
QSpinnerDots?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerDotsProps>>
QSpinnerFacebook?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerFacebookProps>>
QSpinnerGears?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerGearsProps>>
QSpinnerGrid?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerGridProps>>
QSpinnerHearts?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerHeartsProps>>
QSpinnerHourglass?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerHourglassProps>>
QSpinnerInfinity?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerInfinityProps>>
QSpinnerIos?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerIosProps>>
QSpinnerOrbit?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerOrbitProps>>
QSpinnerOval?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerOvalProps>>
QSpinnerPie?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerPieProps>>
QSpinnerPuff?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerPuffProps>>
QSpinnerRadio?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerRadioProps>>
QSpinnerRings?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerRingsProps>>
QSpinnerTail?: PickOptionalProps<OmitFnProps<import("quasar").QSpinnerTailProps>>
QSplitter?: PickOptionalProps<OmitFnProps<import("quasar").QSplitterProps>>
QStep?: PickOptionalProps<OmitFnProps<import("quasar").QStepProps>>
QStepper?: PickOptionalProps<OmitFnProps<import("quasar").QStepperProps>>
QStepperNavigation?: PickOptionalProps<OmitFnProps<import("quasar").QStepperNavigationProps>>
QTabPanel?: PickOptionalProps<OmitFnProps<import("quasar").QTabPanelProps>>
QTabPanels?: PickOptionalProps<OmitFnProps<import("quasar").QTabPanelsProps>>
QTable?: PickOptionalProps<OmitFnProps<import("quasar").QTableProps>>
QTd?: PickOptionalProps<OmitFnProps<import("quasar").QTdProps>>
QTh?: PickOptionalProps<OmitFnProps<import("quasar").QThProps>>
QTr?: PickOptionalProps<OmitFnProps<import("quasar").QTrProps>>
QRouteTab?: PickOptionalProps<OmitFnProps<import("quasar").QRouteTabProps>>
QTab?: PickOptionalProps<OmitFnProps<import("quasar").QTabProps>>
QTabs?: PickOptionalProps<OmitFnProps<import("quasar").QTabsProps>>
QTime?: PickOptionalProps<OmitFnProps<import("quasar").QTimeProps>>
QTimeline?: PickOptionalProps<OmitFnProps<import("quasar").QTimelineProps>>
QTimelineEntry?: PickOptionalProps<OmitFnProps<import("quasar").QTimelineEntryProps>>
QToggle?: PickOptionalProps<OmitFnProps<import("quasar").QToggleProps>>
QToolbar?: PickOptionalProps<OmitFnProps<import("quasar").QToolbarProps>>
QToolbarTitle?: PickOptionalProps<OmitFnProps<import("quasar").QToolbarTitleProps>>
QTooltip?: PickOptionalProps<OmitFnProps<import("quasar").QTooltipProps>>
QTree?: PickOptionalProps<OmitFnProps<import("quasar").QTreeProps>>
QUploader?: PickOptionalProps<OmitFnProps<import("quasar").QUploaderProps>>
QUploaderAddTrigger?: PickOptionalProps<OmitFnProps<import("quasar").QUploaderAddTriggerProps>>
QVideo?: PickOptionalProps<OmitFnProps<import("quasar").QVideoProps>>
QVirtualScroll?: PickOptionalProps<OmitFnProps<import("quasar").QVirtualScrollProps>>
}
}
declare module '@nuxt/schema' {
interface AppConfigInput {
["nuxtQuasar"]?: import("nuxt-quasar-ui").QuasarUIConfiguration
}
interface AppConfig {
["nuxtQuasar"]?: import("nuxt-quasar-ui").QuasarUIConfiguration
}
}
export {}

17
Frontend-Learner/.nuxt/schema/nuxt.schema.d.ts vendored Normal file
View file

@ -0,0 +1,17 @@
export interface NuxtCustomSchema {
}
export type CustomAppConfig = Exclude<NuxtCustomSchema['appConfig'], undefined>
type _CustomAppConfig = CustomAppConfig
declare module '@nuxt/schema' {
interface NuxtConfig extends Omit<NuxtCustomSchema, 'appConfig'> {}
interface NuxtOptions extends Omit<NuxtCustomSchema, 'appConfig'> {}
interface CustomAppConfig extends _CustomAppConfig {}
}
declare module 'nuxt/schema' {
interface NuxtConfig extends Omit<NuxtCustomSchema, 'appConfig'> {}
interface NuxtOptions extends Omit<NuxtCustomSchema, 'appConfig'> {}
interface CustomAppConfig extends _CustomAppConfig {}
}

3
Frontend-Learner/.nuxt/schema/nuxt.schema.json Normal file
View file

@ -0,0 +1,3 @@
{
"id": "#"
}

14
Frontend-Learner/.nuxt/tailwind/postcss.mjs Normal file
View file

@ -0,0 +1,14 @@
// generated by the @nuxtjs/tailwindcss <https://github.com/nuxt-modules/tailwindcss> module at 13/1/2569 10:40:15
import "@nuxtjs/tailwindcss/config-ctx"
import configMerger from "@nuxtjs/tailwindcss/merger";
import cfg2 from "./../../tailwind.config.ts";
const config = [
{"content":{"files":["C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/components/**/*.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/components/**/*.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/layouts/**/*.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/plugins/**/*.{js,ts,mjs}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/composables/**/*.{js,ts,mjs}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/utils/**/*.{js,ts,mjs}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/pages/**/*.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/{A,a}pp.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/{E,e}rror.{vue,js,jsx,mjs,ts,tsx}","C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/app.config.{js,ts,mjs}"]}},
{},
cfg2
].reduce((acc, curr) => configMerger(acc, curr), {});
const resolvedConfig = config;
export default resolvedConfig;

175
Frontend-Learner/.nuxt/tsconfig.json Normal file
View file

@ -0,0 +1,175 @@
{
"compilerOptions": {
"paths": {
"nitropack/types": [
"../node_modules/nitropack/types"
],
"nitropack/runtime": [
"../node_modules/nitropack/runtime"
],
"nitropack": [
"../node_modules/nitropack"
],
"defu": [
"../node_modules/defu"
],
"h3": [
"../node_modules/h3"
],
"consola": [
"../node_modules/consola"
],
"ofetch": [
"../node_modules/ofetch"
],
"@unhead/vue": [
"../node_modules/@unhead/vue"
],
"@nuxt/devtools": [
"../node_modules/@nuxt/devtools"
],
"vue": [
"../node_modules/vue"
],
"@vue/runtime-core": [
"../node_modules/@vue/runtime-core"
],
"@vue/compiler-sfc": [
"../node_modules/@vue/compiler-sfc"
],
"vue-router": [
"../node_modules/vue-router"
],
"vue-router/auto-routes": [
"../node_modules/vue-router/vue-router-auto-routes"
],
"unplugin-vue-router/client": [
"../node_modules/unplugin-vue-router/client"
],
"@nuxt/schema": [
"../node_modules/@nuxt/schema"
],
"nuxt": [
"../node_modules/nuxt"
],
"vite/client": [
"../node_modules/vite/client"
],
"~": [
".."
],
"~/*": [
"../*"
],
"@": [
".."
],
"@/*": [
"../*"
],
"~~": [
".."
],
"~~/*": [
"../*"
],
"@@": [
".."
],
"@@/*": [
"../*"
],
"#shared": [
"../shared"
],
"#shared/*": [
"../shared/*"
],
"assets": [
"../assets"
],
"assets/*": [
"../assets/*"
],
"public": [
"../public"
],
"public/*": [
"../public/*"
],
"#app": [
"../node_modules/nuxt/dist/app"
],
"#app/*": [
"../node_modules/nuxt/dist/app/*"
],
"vue-demi": [
"../node_modules/nuxt/dist/app/compat/vue-demi"
],
"#vue-router": [
"../node_modules/vue-router"
],
"#unhead/composables": [
"../node_modules/nuxt/dist/head/runtime/composables/v3"
],
"#imports": [
"./imports"
],
"#app-manifest": [
"./manifest/meta/dev"
],
"#components": [
"./components"
],
"#build": [
"."
],
"#build/*": [
"./*"
]
},
"esModuleInterop": true,
"skipLibCheck": true,
"target": "ESNext",
"allowJs": true,
"resolveJsonModule": true,
"moduleDetection": "force",
"isolatedModules": true,
"verbatimModuleSyntax": true,
"strict": true,
"noUncheckedIndexedAccess": false,
"forceConsistentCasingInFileNames": true,
"noImplicitOverride": true,
"module": "preserve",
"noEmit": true,
"lib": [
"ESNext",
"dom",
"dom.iterable",
"webworker"
],
"jsx": "preserve",
"jsxImportSource": "vue",
"types": [],
"moduleResolution": "Bundler",
"useDefineForClassFields": true,
"noImplicitThis": true,
"allowSyntheticDefaultImports": true
},
"include": [
"../**/*",
"../.config/nuxt.*",
"./nuxt.d.ts",
"../node_modules/runtime",
"../node_modules/dist/runtime",
".."
],
"exclude": [
"../dist",
"../.data",
"../../node_modules",
"../node_modules/runtime/server",
"../node_modules/dist/runtime/server",
"dev"
]
}

142
Frontend-Learner/.nuxt/tsconfig.server.json Normal file
View file

@ -0,0 +1,142 @@
{
"compilerOptions": {
"forceConsistentCasingInFileNames": true,
"strict": true,
"noEmit": true,
"skipLibCheck": true,
"target": "ESNext",
"module": "ESNext",
"moduleResolution": "Bundler",
"allowJs": true,
"resolveJsonModule": true,
"jsx": "preserve",
"allowSyntheticDefaultImports": true,
"jsxFactory": "h",
"jsxFragmentFactory": "Fragment",
"paths": {
"#imports": [
"./types/nitro-imports"
],
"~/*": [
"../*"
],
"@/*": [
"../*"
],
"~~/*": [
"../*"
],
"@@/*": [
"../*"
],
"nitropack/types": [
"../node_modules/nitropack/types"
],
"nitropack/runtime": [
"../node_modules/nitropack/runtime"
],
"nitropack": [
"../node_modules/nitropack"
],
"defu": [
"../node_modules/defu"
],
"h3": [
"../node_modules/h3"
],
"consola": [
"../node_modules/consola"
],
"ofetch": [
"../node_modules/ofetch"
],
"@unhead/vue": [
"../node_modules/@unhead/vue"
],
"@nuxt/devtools": [
"../node_modules/@nuxt/devtools"
],
"vue": [
"../node_modules/vue"
],
"@vue/runtime-core": [
"../node_modules/@vue/runtime-core"
],
"@vue/compiler-sfc": [
"../node_modules/@vue/compiler-sfc"
],
"vue-router": [
"../node_modules/vue-router"
],
"vue-router/auto-routes": [
"../node_modules/vue-router/vue-router-auto-routes"
],
"unplugin-vue-router/client": [
"../node_modules/unplugin-vue-router/client"
],
"@nuxt/schema": [
"../node_modules/@nuxt/schema"
],
"nuxt": [
"../node_modules/nuxt"
],
"vite/client": [
"../node_modules/vite/client"
],
"#shared": [
"../shared"
],
"#shared/*": [
"../shared/*"
],
"assets": [
"../assets"
],
"assets/*": [
"../assets/*"
],
"public": [
"../public"
],
"public/*": [
"../public/*"
],
"#build": [
"./"
],
"#build/*": [
"./*"
],
"#internal/nuxt/paths": [
"../node_modules/@nuxt/nitro-server/dist/runtime/utils/paths"
],
"#unhead/composables": [
"../node_modules/nuxt/dist/head/runtime/composables/v3"
]
},
"lib": [
"esnext",
"webworker",
"dom.iterable"
]
},
"include": [
"./types/nitro-nuxt.d.ts",
"../node_modules/runtime/server",
"../node_modules/dist/runtime/server",
"../server/**/*",
"../shared/**/*.d.ts",
"./types/nitro.d.ts",
"../**/*"
],
"exclude": [
"../node_modules",
"../../node_modules",
"../node_modules/nuxt/node_modules",
"../node_modules/nuxt-quasar-ui/node_modules",
"../node_modules/@nuxtjs/tailwindcss/node_modules",
"../node_modules/@nuxt/devtools/node_modules",
"../node_modules/@nuxt/telemetry/node_modules",
"../dist"
]
}

7
Frontend-Learner/.nuxt/types/app-defaults.d.ts vendored Normal file
View file

@ -0,0 +1,7 @@
declare module 'nuxt/app/defaults' {
type DefaultAsyncDataErrorValue = null
type DefaultAsyncDataValue = null
type DefaultErrorValue = null
type DedupeOption = boolean | 'cancel' | 'defer'
}

31
Frontend-Learner/.nuxt/types/app.config.d.ts vendored Normal file
View file

@ -0,0 +1,31 @@
import type { CustomAppConfig } from 'nuxt/schema'
import type { Defu } from 'defu'
declare const inlineConfig = {
"nuxt": {}
}
type ResolvedAppConfig = Defu<typeof inlineConfig, []>
type IsAny<T> = 0 extends 1 & T ? true : false
type MergedAppConfig<Resolved extends Record<string, unknown>, Custom extends Record<string, unknown>> = {
[K in keyof (Resolved & Custom)]: K extends keyof Custom
? unknown extends Custom[K]
? Resolved[K]
: IsAny<Custom[K]> extends true
? Resolved[K]
: Custom[K] extends Record<string, any>
? Resolved[K] extends Record<string, any>
? MergedAppConfig<Resolved[K], Custom[K]>
: Exclude<Custom[K], undefined>
: Exclude<Custom[K], undefined>
: Resolved[K]
}
declare module 'nuxt/schema' {
interface AppConfig extends MergedAppConfig<ResolvedAppConfig, CustomAppConfig> { }
}
declare module '@nuxt/schema' {
interface AppConfig extends MergedAppConfig<ResolvedAppConfig, CustomAppConfig> { }
}

25
Frontend-Learner/.nuxt/types/build.d.ts vendored Normal file
View file

@ -0,0 +1,25 @@
declare module "#build/app-component.mjs";
declare module "#build/nitro.client.mjs";
declare module "#build/plugins.client.mjs";
declare module "#build/css.mjs";
declare module "#build/fetch.mjs";
declare module "#build/error-component.mjs";
declare module "#build/global-polyfills.mjs";
declare module "#build/layouts.mjs";
declare module "#build/middleware.mjs";
declare module "#build/nuxt.config.mjs";
declare module "#build/paths.mjs";
declare module "#build/root-component.mjs";
declare module "#build/plugins.server.mjs";
declare module "#build/test-component-wrapper.mjs";
declare module "#build/devtools/settings.mjs";
declare module "#build/runtime.vue-devtools-client.xQLhBfryb_Soh_gqZUVT1KAAO9vjvnTu0mvjILya7us.js";
declare module "#build/routes.mjs";
declare module "#build/pages.mjs";
declare module "#build/router.options.mjs";
declare module "#build/unhead-options.mjs";
declare module "#build/unhead.config.mjs";
declare module "#build/components.plugin.mjs";
declare module "#build/component-names.mjs";
declare module "#build/components.islands.mjs";
declare module "#build/component-chunk.mjs";

1
Frontend-Learner/.nuxt/types/builder-env.d.ts vendored Normal file
View file

@ -0,0 +1 @@
import "vite/client";

335
Frontend-Learner/.nuxt/types/components.d.ts vendored Normal file
View file

@ -0,0 +1,335 @@
import type { DefineComponent, SlotsType } from 'vue'
type IslandComponent<T> = DefineComponent<{}, {refresh: () => Promise<void>}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, SlotsType<{ fallback: { error: unknown } }>> & T
type HydrationStrategies = {
hydrateOnVisible?: IntersectionObserverInit | true
hydrateOnIdle?: number | true
hydrateOnInteraction?: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap> | true
hydrateOnMediaQuery?: string
hydrateAfter?: number
hydrateWhen?: boolean
hydrateNever?: true
}
type LazyComponent<T> = DefineComponent<HydrationStrategies, {}, {}, {}, {}, {}, {}, { hydrated: () => void }> & T
interface _GlobalComponents {
'AppHeader': typeof import("../../components/common/AppHeader.vue").default
'FormInput': typeof import("../../components/common/FormInput.vue").default
'LandingFooter': typeof import("../../components/common/LandingFooter.vue").default
'LandingHeader': typeof import("../../components/common/LandingHeader.vue").default
'LoadingSkeleton': typeof import("../../components/common/LoadingSkeleton.vue").default
'LoadingSpinner': typeof import("../../components/common/LoadingSpinner.vue").default
'MobileNav': typeof import("../../components/common/MobileNav.vue").default
'CourseCard': typeof import("../../components/course/CourseCard.vue").default
'UserAvatar': typeof import("../../components/user/UserAvatar.vue").default
'UserMenu': typeof import("../../components/user/UserMenu.vue").default
'NuxtWelcome': typeof import("../../node_modules/nuxt/dist/app/components/welcome.vue").default
'NuxtLayout': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-layout").default
'NuxtErrorBoundary': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-error-boundary.vue").default
'ClientOnly': typeof import("../../node_modules/nuxt/dist/app/components/client-only").default
'DevOnly': typeof import("../../node_modules/nuxt/dist/app/components/dev-only").default
'ServerPlaceholder': typeof import("../../node_modules/nuxt/dist/app/components/server-placeholder").default
'NuxtLink': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-link").default
'NuxtLoadingIndicator': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-loading-indicator").default
'NuxtTime': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-time.vue").default
'NuxtRouteAnnouncer': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-route-announcer").default
'NuxtImg': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtImg
'NuxtPicture': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtPicture
'QAjaxBar': typeof import("quasar").QAjaxBar
'QAvatar': typeof import("quasar").QAvatar
'QBadge': typeof import("quasar").QBadge
'QBanner': typeof import("quasar").QBanner
'QBar': typeof import("quasar").QBar
'QBreadcrumbs': typeof import("quasar").QBreadcrumbs
'QBreadcrumbsEl': typeof import("quasar").QBreadcrumbsEl
'QBtn': typeof import("quasar").QBtn
'QBtnDropdown': typeof import("quasar").QBtnDropdown
'QBtnGroup': typeof import("quasar").QBtnGroup
'QBtnToggle': typeof import("quasar").QBtnToggle
'QCard': typeof import("quasar").QCard
'QCardActions': typeof import("quasar").QCardActions
'QCardSection': typeof import("quasar").QCardSection
'QCarousel': typeof import("quasar").QCarousel
'QCarouselControl': typeof import("quasar").QCarouselControl
'QCarouselSlide': typeof import("quasar").QCarouselSlide
'QChatMessage': typeof import("quasar").QChatMessage
'QCheckbox': typeof import("quasar").QCheckbox
'QChip': typeof import("quasar").QChip
'QCircularProgress': typeof import("quasar").QCircularProgress
'QColor': typeof import("quasar").QColor
'QDate': typeof import("quasar").QDate
'QDialog': typeof import("quasar").QDialog
'QDrawer': typeof import("quasar").QDrawer
'QEditor': typeof import("quasar").QEditor
'QExpansionItem': typeof import("quasar").QExpansionItem
'QFab': typeof import("quasar").QFab
'QFabAction': typeof import("quasar").QFabAction
'QField': typeof import("quasar").QField
'QFile': typeof import("quasar").QFile
'QFooter': typeof import("quasar").QFooter
'QForm': typeof import("quasar").QForm
'QFormChildMixin': typeof import("quasar").QFormChildMixin
'QHeader': typeof import("quasar").QHeader
'QIcon': typeof import("quasar").QIcon
'QImg': typeof import("quasar").QImg
'QInfiniteScroll': typeof import("quasar").QInfiniteScroll
'QInnerLoading': typeof import("quasar").QInnerLoading
'QInput': typeof import("quasar").QInput
'QIntersection': typeof import("quasar").QIntersection
'QItem': typeof import("quasar").QItem
'QItemLabel': typeof import("quasar").QItemLabel
'QItemSection': typeof import("quasar").QItemSection
'QList': typeof import("quasar").QList
'QKnob': typeof import("quasar").QKnob
'QLayout': typeof import("quasar").QLayout
'QLinearProgress': typeof import("quasar").QLinearProgress
'QMarkupTable': typeof import("quasar").QMarkupTable
'QMenu': typeof import("quasar").QMenu
'QNoSsr': typeof import("quasar").QNoSsr
'QOptionGroup': typeof import("quasar").QOptionGroup
'QPage': typeof import("quasar").QPage
'QPageContainer': typeof import("quasar").QPageContainer
'QPageScroller': typeof import("quasar").QPageScroller
'QPageSticky': typeof import("quasar").QPageSticky
'QPagination': typeof import("quasar").QPagination
'QParallax': typeof import("quasar").QParallax
'QPopupEdit': typeof import("quasar").QPopupEdit
'QPopupProxy': typeof import("quasar").QPopupProxy
'QPullToRefresh': typeof import("quasar").QPullToRefresh
'QRadio': typeof import("quasar").QRadio
'QRange': typeof import("quasar").QRange
'QRating': typeof import("quasar").QRating
'QResizeObserver': typeof import("quasar").QResizeObserver
'QResponsive': typeof import("quasar").QResponsive
'QScrollArea': typeof import("quasar").QScrollArea
'QScrollObserver': typeof import("quasar").QScrollObserver
'QSelect': typeof import("quasar").QSelect
'QSeparator': typeof import("quasar").QSeparator
'QSkeleton': typeof import("quasar").QSkeleton
'QSlideItem': typeof import("quasar").QSlideItem
'QSlideTransition': typeof import("quasar").QSlideTransition
'QSlider': typeof import("quasar").QSlider
'QSpace': typeof import("quasar").QSpace
'QSpinner': typeof import("quasar").QSpinner
'QSpinnerAudio': typeof import("quasar").QSpinnerAudio
'QSpinnerBall': typeof import("quasar").QSpinnerBall
'QSpinnerBars': typeof import("quasar").QSpinnerBars
'QSpinnerBox': typeof import("quasar").QSpinnerBox
'QSpinnerClock': typeof import("quasar").QSpinnerClock
'QSpinnerComment': typeof import("quasar").QSpinnerComment
'QSpinnerCube': typeof import("quasar").QSpinnerCube
'QSpinnerDots': typeof import("quasar").QSpinnerDots
'QSpinnerFacebook': typeof import("quasar").QSpinnerFacebook
'QSpinnerGears': typeof import("quasar").QSpinnerGears
'QSpinnerGrid': typeof import("quasar").QSpinnerGrid
'QSpinnerHearts': typeof import("quasar").QSpinnerHearts
'QSpinnerHourglass': typeof import("quasar").QSpinnerHourglass
'QSpinnerInfinity': typeof import("quasar").QSpinnerInfinity
'QSpinnerIos': typeof import("quasar").QSpinnerIos
'QSpinnerOrbit': typeof import("quasar").QSpinnerOrbit
'QSpinnerOval': typeof import("quasar").QSpinnerOval
'QSpinnerPie': typeof import("quasar").QSpinnerPie
'QSpinnerPuff': typeof import("quasar").QSpinnerPuff
'QSpinnerRadio': typeof import("quasar").QSpinnerRadio
'QSpinnerRings': typeof import("quasar").QSpinnerRings
'QSpinnerTail': typeof import("quasar").QSpinnerTail
'QSplitter': typeof import("quasar").QSplitter
'QStep': typeof import("quasar").QStep
'QStepper': typeof import("quasar").QStepper
'QStepperNavigation': typeof import("quasar").QStepperNavigation
'QTabPanel': typeof import("quasar").QTabPanel
'QTabPanels': typeof import("quasar").QTabPanels
'QTable': typeof import("quasar").QTable
'QTd': typeof import("quasar").QTd
'QTh': typeof import("quasar").QTh
'QTr': typeof import("quasar").QTr
'QRouteTab': typeof import("quasar").QRouteTab
'QTab': typeof import("quasar").QTab
'QTabs': typeof import("quasar").QTabs
'QTime': typeof import("quasar").QTime
'QTimeline': typeof import("quasar").QTimeline
'QTimelineEntry': typeof import("quasar").QTimelineEntry
'QToggle': typeof import("quasar").QToggle
'QToolbar': typeof import("quasar").QToolbar
'QToolbarTitle': typeof import("quasar").QToolbarTitle
'QTooltip': typeof import("quasar").QTooltip
'QTree': typeof import("quasar").QTree
'QUploader': typeof import("quasar").QUploader
'QUploaderAddTrigger': typeof import("quasar").QUploaderAddTrigger
'QVideo': typeof import("quasar").QVideo
'QVirtualScroll': typeof import("quasar").QVirtualScroll
'NuxtPage': typeof import("../../node_modules/nuxt/dist/pages/runtime/page").default
'NoScript': typeof import("../../node_modules/nuxt/dist/head/runtime/components").NoScript
'Link': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Link
'Base': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Base
'Title': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Title
'Meta': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Meta
'Style': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Style
'Head': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Head
'Html': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Html
'Body': typeof import("../../node_modules/nuxt/dist/head/runtime/components").Body
'NuxtIsland': typeof import("../../node_modules/nuxt/dist/app/components/nuxt-island").default
'LazyAppHeader': LazyComponent<typeof import("../../components/common/AppHeader.vue").default>
'LazyFormInput': LazyComponent<typeof import("../../components/common/FormInput.vue").default>
'LazyLandingFooter': LazyComponent<typeof import("../../components/common/LandingFooter.vue").default>
'LazyLandingHeader': LazyComponent<typeof import("../../components/common/LandingHeader.vue").default>
'LazyLoadingSkeleton': LazyComponent<typeof import("../../components/common/LoadingSkeleton.vue").default>
'LazyLoadingSpinner': LazyComponent<typeof import("../../components/common/LoadingSpinner.vue").default>
'LazyMobileNav': LazyComponent<typeof import("../../components/common/MobileNav.vue").default>
'LazyCourseCard': LazyComponent<typeof import("../../components/course/CourseCard.vue").default>
'LazyUserAvatar': LazyComponent<typeof import("../../components/user/UserAvatar.vue").default>
'LazyUserMenu': LazyComponent<typeof import("../../components/user/UserMenu.vue").default>
'LazyNuxtWelcome': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/welcome.vue").default>
'LazyNuxtLayout': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-layout").default>
'LazyNuxtErrorBoundary': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-error-boundary.vue").default>
'LazyClientOnly': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/client-only").default>
'LazyDevOnly': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/dev-only").default>
'LazyServerPlaceholder': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/server-placeholder").default>
'LazyNuxtLink': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-link").default>
'LazyNuxtLoadingIndicator': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-loading-indicator").default>
'LazyNuxtTime': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-time.vue").default>
'LazyNuxtRouteAnnouncer': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-route-announcer").default>
'LazyNuxtImg': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtImg>
'LazyNuxtPicture': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-stubs").NuxtPicture>
'LazyQAjaxBar': LazyComponent<typeof import("quasar").QAjaxBar>
'LazyQAvatar': LazyComponent<typeof import("quasar").QAvatar>
'LazyQBadge': LazyComponent<typeof import("quasar").QBadge>
'LazyQBanner': LazyComponent<typeof import("quasar").QBanner>
'LazyQBar': LazyComponent<typeof import("quasar").QBar>
'LazyQBreadcrumbs': LazyComponent<typeof import("quasar").QBreadcrumbs>
'LazyQBreadcrumbsEl': LazyComponent<typeof import("quasar").QBreadcrumbsEl>
'LazyQBtn': LazyComponent<typeof import("quasar").QBtn>
'LazyQBtnDropdown': LazyComponent<typeof import("quasar").QBtnDropdown>
'LazyQBtnGroup': LazyComponent<typeof import("quasar").QBtnGroup>
'LazyQBtnToggle': LazyComponent<typeof import("quasar").QBtnToggle>
'LazyQCard': LazyComponent<typeof import("quasar").QCard>
'LazyQCardActions': LazyComponent<typeof import("quasar").QCardActions>
'LazyQCardSection': LazyComponent<typeof import("quasar").QCardSection>
'LazyQCarousel': LazyComponent<typeof import("quasar").QCarousel>
'LazyQCarouselControl': LazyComponent<typeof import("quasar").QCarouselControl>
'LazyQCarouselSlide': LazyComponent<typeof import("quasar").QCarouselSlide>
'LazyQChatMessage': LazyComponent<typeof import("quasar").QChatMessage>
'LazyQCheckbox': LazyComponent<typeof import("quasar").QCheckbox>
'LazyQChip': LazyComponent<typeof import("quasar").QChip>
'LazyQCircularProgress': LazyComponent<typeof import("quasar").QCircularProgress>
'LazyQColor': LazyComponent<typeof import("quasar").QColor>
'LazyQDate': LazyComponent<typeof import("quasar").QDate>
'LazyQDialog': LazyComponent<typeof import("quasar").QDialog>
'LazyQDrawer': LazyComponent<typeof import("quasar").QDrawer>
'LazyQEditor': LazyComponent<typeof import("quasar").QEditor>
'LazyQExpansionItem': LazyComponent<typeof import("quasar").QExpansionItem>
'LazyQFab': LazyComponent<typeof import("quasar").QFab>
'LazyQFabAction': LazyComponent<typeof import("quasar").QFabAction>
'LazyQField': LazyComponent<typeof import("quasar").QField>
'LazyQFile': LazyComponent<typeof import("quasar").QFile>
'LazyQFooter': LazyComponent<typeof import("quasar").QFooter>
'LazyQForm': LazyComponent<typeof import("quasar").QForm>
'LazyQFormChildMixin': LazyComponent<typeof import("quasar").QFormChildMixin>
'LazyQHeader': LazyComponent<typeof import("quasar").QHeader>
'LazyQIcon': LazyComponent<typeof import("quasar").QIcon>
'LazyQImg': LazyComponent<typeof import("quasar").QImg>
'LazyQInfiniteScroll': LazyComponent<typeof import("quasar").QInfiniteScroll>
'LazyQInnerLoading': LazyComponent<typeof import("quasar").QInnerLoading>
'LazyQInput': LazyComponent<typeof import("quasar").QInput>
'LazyQIntersection': LazyComponent<typeof import("quasar").QIntersection>
'LazyQItem': LazyComponent<typeof import("quasar").QItem>
'LazyQItemLabel': LazyComponent<typeof import("quasar").QItemLabel>
'LazyQItemSection': LazyComponent<typeof import("quasar").QItemSection>
'LazyQList': LazyComponent<typeof import("quasar").QList>
'LazyQKnob': LazyComponent<typeof import("quasar").QKnob>
'LazyQLayout': LazyComponent<typeof import("quasar").QLayout>
'LazyQLinearProgress': LazyComponent<typeof import("quasar").QLinearProgress>
'LazyQMarkupTable': LazyComponent<typeof import("quasar").QMarkupTable>
'LazyQMenu': LazyComponent<typeof import("quasar").QMenu>
'LazyQNoSsr': LazyComponent<typeof import("quasar").QNoSsr>
'LazyQOptionGroup': LazyComponent<typeof import("quasar").QOptionGroup>
'LazyQPage': LazyComponent<typeof import("quasar").QPage>
'LazyQPageContainer': LazyComponent<typeof import("quasar").QPageContainer>
'LazyQPageScroller': LazyComponent<typeof import("quasar").QPageScroller>
'LazyQPageSticky': LazyComponent<typeof import("quasar").QPageSticky>
'LazyQPagination': LazyComponent<typeof import("quasar").QPagination>
'LazyQParallax': LazyComponent<typeof import("quasar").QParallax>
'LazyQPopupEdit': LazyComponent<typeof import("quasar").QPopupEdit>
'LazyQPopupProxy': LazyComponent<typeof import("quasar").QPopupProxy>
'LazyQPullToRefresh': LazyComponent<typeof import("quasar").QPullToRefresh>
'LazyQRadio': LazyComponent<typeof import("quasar").QRadio>
'LazyQRange': LazyComponent<typeof import("quasar").QRange>
'LazyQRating': LazyComponent<typeof import("quasar").QRating>
'LazyQResizeObserver': LazyComponent<typeof import("quasar").QResizeObserver>
'LazyQResponsive': LazyComponent<typeof import("quasar").QResponsive>
'LazyQScrollArea': LazyComponent<typeof import("quasar").QScrollArea>
'LazyQScrollObserver': LazyComponent<typeof import("quasar").QScrollObserver>
'LazyQSelect': LazyComponent<typeof import("quasar").QSelect>
'LazyQSeparator': LazyComponent<typeof import("quasar").QSeparator>
'LazyQSkeleton': LazyComponent<typeof import("quasar").QSkeleton>
'LazyQSlideItem': LazyComponent<typeof import("quasar").QSlideItem>
'LazyQSlideTransition': LazyComponent<typeof import("quasar").QSlideTransition>
'LazyQSlider': LazyComponent<typeof import("quasar").QSlider>
'LazyQSpace': LazyComponent<typeof import("quasar").QSpace>
'LazyQSpinner': LazyComponent<typeof import("quasar").QSpinner>
'LazyQSpinnerAudio': LazyComponent<typeof import("quasar").QSpinnerAudio>
'LazyQSpinnerBall': LazyComponent<typeof import("quasar").QSpinnerBall>
'LazyQSpinnerBars': LazyComponent<typeof import("quasar").QSpinnerBars>
'LazyQSpinnerBox': LazyComponent<typeof import("quasar").QSpinnerBox>
'LazyQSpinnerClock': LazyComponent<typeof import("quasar").QSpinnerClock>
'LazyQSpinnerComment': LazyComponent<typeof import("quasar").QSpinnerComment>
'LazyQSpinnerCube': LazyComponent<typeof import("quasar").QSpinnerCube>
'LazyQSpinnerDots': LazyComponent<typeof import("quasar").QSpinnerDots>
'LazyQSpinnerFacebook': LazyComponent<typeof import("quasar").QSpinnerFacebook>
'LazyQSpinnerGears': LazyComponent<typeof import("quasar").QSpinnerGears>
'LazyQSpinnerGrid': LazyComponent<typeof import("quasar").QSpinnerGrid>
'LazyQSpinnerHearts': LazyComponent<typeof import("quasar").QSpinnerHearts>
'LazyQSpinnerHourglass': LazyComponent<typeof import("quasar").QSpinnerHourglass>
'LazyQSpinnerInfinity': LazyComponent<typeof import("quasar").QSpinnerInfinity>
'LazyQSpinnerIos': LazyComponent<typeof import("quasar").QSpinnerIos>
'LazyQSpinnerOrbit': LazyComponent<typeof import("quasar").QSpinnerOrbit>
'LazyQSpinnerOval': LazyComponent<typeof import("quasar").QSpinnerOval>
'LazyQSpinnerPie': LazyComponent<typeof import("quasar").QSpinnerPie>
'LazyQSpinnerPuff': LazyComponent<typeof import("quasar").QSpinnerPuff>
'LazyQSpinnerRadio': LazyComponent<typeof import("quasar").QSpinnerRadio>
'LazyQSpinnerRings': LazyComponent<typeof import("quasar").QSpinnerRings>
'LazyQSpinnerTail': LazyComponent<typeof import("quasar").QSpinnerTail>
'LazyQSplitter': LazyComponent<typeof import("quasar").QSplitter>
'LazyQStep': LazyComponent<typeof import("quasar").QStep>
'LazyQStepper': LazyComponent<typeof import("quasar").QStepper>
'LazyQStepperNavigation': LazyComponent<typeof import("quasar").QStepperNavigation>
'LazyQTabPanel': LazyComponent<typeof import("quasar").QTabPanel>
'LazyQTabPanels': LazyComponent<typeof import("quasar").QTabPanels>
'LazyQTable': LazyComponent<typeof import("quasar").QTable>
'LazyQTd': LazyComponent<typeof import("quasar").QTd>
'LazyQTh': LazyComponent<typeof import("quasar").QTh>
'LazyQTr': LazyComponent<typeof import("quasar").QTr>
'LazyQRouteTab': LazyComponent<typeof import("quasar").QRouteTab>
'LazyQTab': LazyComponent<typeof import("quasar").QTab>
'LazyQTabs': LazyComponent<typeof import("quasar").QTabs>
'LazyQTime': LazyComponent<typeof import("quasar").QTime>
'LazyQTimeline': LazyComponent<typeof import("quasar").QTimeline>
'LazyQTimelineEntry': LazyComponent<typeof import("quasar").QTimelineEntry>
'LazyQToggle': LazyComponent<typeof import("quasar").QToggle>
'LazyQToolbar': LazyComponent<typeof import("quasar").QToolbar>
'LazyQToolbarTitle': LazyComponent<typeof import("quasar").QToolbarTitle>
'LazyQTooltip': LazyComponent<typeof import("quasar").QTooltip>
'LazyQTree': LazyComponent<typeof import("quasar").QTree>
'LazyQUploader': LazyComponent<typeof import("quasar").QUploader>
'LazyQUploaderAddTrigger': LazyComponent<typeof import("quasar").QUploaderAddTrigger>
'LazyQVideo': LazyComponent<typeof import("quasar").QVideo>
'LazyQVirtualScroll': LazyComponent<typeof import("quasar").QVirtualScroll>
'LazyNuxtPage': LazyComponent<typeof import("../../node_modules/nuxt/dist/pages/runtime/page").default>
'LazyNoScript': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").NoScript>
'LazyLink': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Link>
'LazyBase': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Base>
'LazyTitle': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Title>
'LazyMeta': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Meta>
'LazyStyle': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Style>
'LazyHead': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Head>
'LazyHtml': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Html>
'LazyBody': LazyComponent<typeof import("../../node_modules/nuxt/dist/head/runtime/components").Body>
'LazyNuxtIsland': LazyComponent<typeof import("../../node_modules/nuxt/dist/app/components/nuxt-island").default>
}
declare module 'vue' {
export interface GlobalComponents extends _GlobalComponents { }
}
export {}

391
Frontend-Learner/.nuxt/types/imports.d.ts vendored Normal file
View file

@ -0,0 +1,391 @@
// Generated by auto imports
export {}
declare global {
const Notify: typeof import('quasar').Notify
const abortNavigation: typeof import('../../node_modules/nuxt/dist/app/composables/router').abortNavigation
const addRouteMiddleware: typeof import('../../node_modules/nuxt/dist/app/composables/router').addRouteMiddleware
const callOnce: typeof import('../../node_modules/nuxt/dist/app/composables/once').callOnce
const cancelIdleCallback: typeof import('../../node_modules/nuxt/dist/app/compat/idle-callback').cancelIdleCallback
const clearError: typeof import('../../node_modules/nuxt/dist/app/composables/error').clearError
const clearNuxtData: typeof import('../../node_modules/nuxt/dist/app/composables/asyncData').clearNuxtData
const clearNuxtState: typeof import('../../node_modules/nuxt/dist/app/composables/state').clearNuxtState
const computed: typeof import('../../node_modules/vue').computed
const createError: typeof import('../../node_modules/nuxt/dist/app/composables/error').createError
const customRef: typeof import('../../node_modules/vue').customRef
const defineAppConfig: typeof import('../../node_modules/nuxt/dist/app/nuxt').defineAppConfig
const defineAsyncComponent: typeof import('../../node_modules/vue').defineAsyncComponent
const defineComponent: typeof import('../../node_modules/vue').defineComponent
const defineLazyHydrationComponent: typeof import('../../node_modules/nuxt/dist/app/composables/lazy-hydration').defineLazyHydrationComponent
const defineNuxtComponent: typeof import('../../node_modules/nuxt/dist/app/composables/component').defineNuxtComponent
const defineNuxtLink: typeof import('../../node_modules/nuxt/dist/app/components/nuxt-link').defineNuxtLink
const defineNuxtPlugin: typeof import('../../node_modules/nuxt/dist/app/nuxt').defineNuxtPlugin
const defineNuxtRouteMiddleware: typeof import('../../node_modules/nuxt/dist/app/composables/router').defineNuxtRouteMiddleware
const definePageMeta: typeof import('../../node_modules/nuxt/dist/pages/runtime/composables').definePageMeta
const definePayloadPlugin: typeof import('../../node_modules/nuxt/dist/app/nuxt').definePayloadPlugin
const definePayloadReducer: typeof import('../../node_modules/nuxt/dist/app/composables/payload').definePayloadReducer
const definePayloadReviver: typeof import('../../node_modules/nuxt/dist/app/composables/payload').definePayloadReviver
const effect: typeof import('../../node_modules/vue').effect
const effectScope: typeof import('../../node_modules/vue').effectScope
const getAppManifest: typeof import('../../node_modules/nuxt/dist/app/composables/manifest').getAppManifest
const getCurrentInstance: typeof import('../../node_modules/vue').getCurrentInstance
const getCurrentScope: typeof import('../../node_modules/vue').getCurrentScope
const getRouteRules: typeof import('../../node_modules/nuxt/dist/app/composables/manifest').getRouteRules
const h: typeof import('../../node_modules/vue').h
const hasInjectionContext: typeof import('../../node_modules/vue').hasInjectionContext
const inject: typeof import('../../node_modules/vue').inject
const injectHead: typeof import('../../node_modules/nuxt/dist/app/composables/head').injectHead
const isNuxtError: typeof import('../../node_modules/nuxt/dist/app/composables/error').isNuxtError
const isPrerendered: typeof import('../../node_modules/nuxt/dist/app/composables/payload').isPrerendered
const isProxy: typeof import('../../node_modules/vue').isProxy
const isReactive: typeof import('../../node_modules/vue').isReactive
const isReadonly: typeof import('../../node_modules/vue').isReadonly
const isRef: typeof import('../../node_modules/vue').isRef
const isShallow: typeof import('../../node_modules/vue').isShallow
const isVue2: typeof import('../../node_modules/nuxt/dist/app/compat/vue-demi').isVue2
const isVue3: typeof import('../../node_modules/nuxt/dist/app/compat/vue-demi').isVue3
const loadPayload: typeof import('../../node_modules/nuxt/dist/app/composables/payload').loadPayload
const markRaw: typeof import('../../node_modules/vue').markRaw
const navigateTo: typeof import('../../node_modules/nuxt/dist/app/composables/router').navigateTo
const nextTick: typeof import('../../node_modules/vue').nextTick
const onActivated: typeof import('../../node_modules/vue').onActivated
const onBeforeMount: typeof import('../../node_modules/vue').onBeforeMount
const onBeforeRouteLeave: typeof import('../../node_modules/vue-router').onBeforeRouteLeave
const onBeforeRouteUpdate: typeof import('../../node_modules/vue-router').onBeforeRouteUpdate
const onBeforeUnmount: typeof import('../../node_modules/vue').onBeforeUnmount
const onBeforeUpdate: typeof import('../../node_modules/vue').onBeforeUpdate
const onDeactivated: typeof import('../../node_modules/vue').onDeactivated
const onErrorCaptured: typeof import('../../node_modules/vue').onErrorCaptured
const onMounted: typeof import('../../node_modules/vue').onMounted
const onNuxtReady: typeof import('../../node_modules/nuxt/dist/app/composables/ready').onNuxtReady
const onPrehydrate: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').onPrehydrate
const onRenderTracked: typeof import('../../node_modules/vue').onRenderTracked
const onRenderTriggered: typeof import('../../node_modules/vue').onRenderTriggered
const onScopeDispose: typeof import('../../node_modules/vue').onScopeDispose
const onServerPrefetch: typeof import('../../node_modules/vue').onServerPrefetch
const onUnmounted: typeof import('../../node_modules/vue').onUnmounted
const onUpdated: typeof import('../../node_modules/vue').onUpdated
const onWatcherCleanup: typeof import('../../node_modules/vue').onWatcherCleanup
const prefetchComponents: typeof import('../../node_modules/nuxt/dist/app/composables/preload').prefetchComponents
const preloadComponents: typeof import('../../node_modules/nuxt/dist/app/composables/preload').preloadComponents
const preloadPayload: typeof import('../../node_modules/nuxt/dist/app/composables/payload').preloadPayload
const preloadRouteComponents: typeof import('../../node_modules/nuxt/dist/app/composables/preload').preloadRouteComponents
const prerenderRoutes: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').prerenderRoutes
const provide: typeof import('../../node_modules/vue').provide
const proxyRefs: typeof import('../../node_modules/vue').proxyRefs
const reactive: typeof import('../../node_modules/vue').reactive
const readonly: typeof import('../../node_modules/vue').readonly
const ref: typeof import('../../node_modules/vue').ref
const refreshCookie: typeof import('../../node_modules/nuxt/dist/app/composables/cookie').refreshCookie
const refreshNuxtData: typeof import('../../node_modules/nuxt/dist/app/composables/asyncData').refreshNuxtData
const reloadNuxtApp: typeof import('../../node_modules/nuxt/dist/app/composables/chunk').reloadNuxtApp
const requestIdleCallback: typeof import('../../node_modules/nuxt/dist/app/compat/idle-callback').requestIdleCallback
const resolveComponent: typeof import('../../node_modules/vue').resolveComponent
const setInterval: typeof import('../../node_modules/nuxt/dist/app/compat/interval').setInterval
const setPageLayout: typeof import('../../node_modules/nuxt/dist/app/composables/router').setPageLayout
const setResponseStatus: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').setResponseStatus
const shallowReactive: typeof import('../../node_modules/vue').shallowReactive
const shallowReadonly: typeof import('../../node_modules/vue').shallowReadonly
const shallowRef: typeof import('../../node_modules/vue').shallowRef
const showError: typeof import('../../node_modules/nuxt/dist/app/composables/error').showError
const toRaw: typeof import('../../node_modules/vue').toRaw
const toRef: typeof import('../../node_modules/vue').toRef
const toRefs: typeof import('../../node_modules/vue').toRefs
const toValue: typeof import('../../node_modules/vue').toValue
const triggerRef: typeof import('../../node_modules/vue').triggerRef
const tryUseNuxtApp: typeof import('../../node_modules/nuxt/dist/app/nuxt').tryUseNuxtApp
const unref: typeof import('../../node_modules/vue').unref
const updateAppConfig: typeof import('../../node_modules/nuxt/dist/app/config').updateAppConfig
const useAppConfig: typeof import('../../node_modules/nuxt/dist/app/config').useAppConfig
const useAsyncData: typeof import('../../node_modules/nuxt/dist/app/composables/asyncData').useAsyncData
const useAttrs: typeof import('../../node_modules/vue').useAttrs
const useAuth: typeof import('../../composables/useAuth').useAuth
const useCookie: typeof import('../../node_modules/nuxt/dist/app/composables/cookie').useCookie
const useCssModule: typeof import('../../node_modules/vue').useCssModule
const useCssVars: typeof import('../../node_modules/vue').useCssVars
const useDialogPluginComponent: typeof import('quasar').useDialogPluginComponent
const useError: typeof import('../../node_modules/nuxt/dist/app/composables/error').useError
const useFetch: typeof import('../../node_modules/nuxt/dist/app/composables/fetch').useFetch
const useFormChild: typeof import('quasar').useFormChild
const useFormValidation: typeof import('../../composables/useFormValidation').useFormValidation
const useHead: typeof import('../../node_modules/nuxt/dist/app/composables/head').useHead
const useHeadSafe: typeof import('../../node_modules/nuxt/dist/app/composables/head').useHeadSafe
const useHydration: typeof import('../../node_modules/nuxt/dist/app/composables/hydrate').useHydration
const useId: typeof import('../../node_modules/vue').useId
const useInterval: typeof import('quasar').useInterval
const useLazyAsyncData: typeof import('../../node_modules/nuxt/dist/app/composables/asyncData').useLazyAsyncData
const useLazyFetch: typeof import('../../node_modules/nuxt/dist/app/composables/fetch').useLazyFetch
const useLink: typeof import('../../node_modules/vue-router').useLink
const useLoadingIndicator: typeof import('../../node_modules/nuxt/dist/app/composables/loading-indicator').useLoadingIndicator
const useMeta: typeof import('quasar').useMeta
const useModel: typeof import('../../node_modules/vue').useModel
const useNuxtApp: typeof import('../../node_modules/nuxt/dist/app/nuxt').useNuxtApp
const useNuxtData: typeof import('../../node_modules/nuxt/dist/app/composables/asyncData').useNuxtData
const useNuxtDevTools: typeof import('../../node_modules/@nuxt/devtools/dist/runtime/use-nuxt-devtools').useNuxtDevTools
const usePreviewMode: typeof import('../../node_modules/nuxt/dist/app/composables/preview').usePreviewMode
const useQuasar: typeof import('quasar').useQuasar
const useRenderCache: typeof import('quasar').useRenderCache
const useRequestEvent: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').useRequestEvent
const useRequestFetch: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').useRequestFetch
const useRequestHeader: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').useRequestHeader
const useRequestHeaders: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').useRequestHeaders
const useRequestURL: typeof import('../../node_modules/nuxt/dist/app/composables/url').useRequestURL
const useResponseHeader: typeof import('../../node_modules/nuxt/dist/app/composables/ssr').useResponseHeader
const useRoute: typeof import('../../node_modules/nuxt/dist/app/composables/router').useRoute
const useRouteAnnouncer: typeof import('../../node_modules/nuxt/dist/app/composables/route-announcer').useRouteAnnouncer
const useRouter: typeof import('../../node_modules/nuxt/dist/app/composables/router').useRouter
const useRuntimeConfig: typeof import('../../node_modules/nuxt/dist/app/nuxt').useRuntimeConfig
const useRuntimeHook: typeof import('../../node_modules/nuxt/dist/app/composables/runtime-hook').useRuntimeHook
const useScript: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScript
const useScriptClarity: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptClarity
const useScriptCloudflareWebAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptCloudflareWebAnalytics
const useScriptCrisp: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptCrisp
const useScriptDatabuddyAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptDatabuddyAnalytics
const useScriptEventPage: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptEventPage
const useScriptFathomAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptFathomAnalytics
const useScriptGoogleAdsense: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptGoogleAdsense
const useScriptGoogleAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptGoogleAnalytics
const useScriptGoogleMaps: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptGoogleMaps
const useScriptGoogleTagManager: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptGoogleTagManager
const useScriptHotjar: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptHotjar
const useScriptIntercom: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptIntercom
const useScriptLemonSqueezy: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptLemonSqueezy
const useScriptMatomoAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptMatomoAnalytics
const useScriptMetaPixel: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptMetaPixel
const useScriptNpm: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptNpm
const useScriptPayPal: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptPayPal
const useScriptPlausibleAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptPlausibleAnalytics
const useScriptRedditPixel: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptRedditPixel
const useScriptRybbitAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptRybbitAnalytics
const useScriptSegment: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptSegment
const useScriptSnapchatPixel: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptSnapchatPixel
const useScriptStripe: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptStripe
const useScriptTriggerConsent: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptTriggerConsent
const useScriptTriggerElement: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptTriggerElement
const useScriptUmamiAnalytics: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptUmamiAnalytics
const useScriptVimeoPlayer: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptVimeoPlayer
const useScriptXPixel: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptXPixel
const useScriptYouTubePlayer: typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs').useScriptYouTubePlayer
const useSeoMeta: typeof import('../../node_modules/nuxt/dist/app/composables/head').useSeoMeta
const useServerHead: typeof import('../../node_modules/nuxt/dist/app/composables/head').useServerHead
const useServerHeadSafe: typeof import('../../node_modules/nuxt/dist/app/composables/head').useServerHeadSafe
const useServerSeoMeta: typeof import('../../node_modules/nuxt/dist/app/composables/head').useServerSeoMeta
const useShadowRoot: typeof import('../../node_modules/vue').useShadowRoot
const useSlots: typeof import('../../node_modules/vue').useSlots
const useSplitAttrs: typeof import('quasar').useSplitAttrs
const useState: typeof import('../../node_modules/nuxt/dist/app/composables/state').useState
const useTemplateRef: typeof import('../../node_modules/vue').useTemplateRef
const useTick: typeof import('quasar').useTick
const useTimeout: typeof import('quasar').useTimeout
const useTransitionState: typeof import('../../node_modules/vue').useTransitionState
const watch: typeof import('../../node_modules/vue').watch
const watchEffect: typeof import('../../node_modules/vue').watchEffect
const watchPostEffect: typeof import('../../node_modules/vue').watchPostEffect
const watchSyncEffect: typeof import('../../node_modules/vue').watchSyncEffect
const withCtx: typeof import('../../node_modules/vue').withCtx
const withDirectives: typeof import('../../node_modules/vue').withDirectives
const withKeys: typeof import('../../node_modules/vue').withKeys
const withMemo: typeof import('../../node_modules/vue').withMemo
const withModifiers: typeof import('../../node_modules/vue').withModifiers
const withScopeId: typeof import('../../node_modules/vue').withScopeId
}
// for type re-export
declare global {
// @ts-ignore
export type { Component, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from '../../node_modules/vue'
import('../../node_modules/vue')
// @ts-ignore
export type { ValidationRule, FieldErrors } from '../../composables/useFormValidation'
import('../../composables/useFormValidation')
}
// for vue template auto import
import { UnwrapRef } from 'vue'
declare module 'vue' {
interface ComponentCustomProperties {
readonly Notify: UnwrapRef<typeof import('quasar')['Notify']>
readonly abortNavigation: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['abortNavigation']>
readonly addRouteMiddleware: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['addRouteMiddleware']>
readonly callOnce: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/once')['callOnce']>
readonly cancelIdleCallback: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/compat/idle-callback')['cancelIdleCallback']>
readonly clearError: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/error')['clearError']>
readonly clearNuxtData: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/asyncData')['clearNuxtData']>
readonly clearNuxtState: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/state')['clearNuxtState']>
readonly computed: UnwrapRef<typeof import('../../node_modules/vue')['computed']>
readonly createError: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/error')['createError']>
readonly customRef: UnwrapRef<typeof import('../../node_modules/vue')['customRef']>
readonly defineAppConfig: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['defineAppConfig']>
readonly defineAsyncComponent: UnwrapRef<typeof import('../../node_modules/vue')['defineAsyncComponent']>
readonly defineComponent: UnwrapRef<typeof import('../../node_modules/vue')['defineComponent']>
readonly defineLazyHydrationComponent: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/lazy-hydration')['defineLazyHydrationComponent']>
readonly defineNuxtComponent: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/component')['defineNuxtComponent']>
readonly defineNuxtLink: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/components/nuxt-link')['defineNuxtLink']>
readonly defineNuxtPlugin: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['defineNuxtPlugin']>
readonly defineNuxtRouteMiddleware: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['defineNuxtRouteMiddleware']>
readonly definePageMeta: UnwrapRef<typeof import('../../node_modules/nuxt/dist/pages/runtime/composables')['definePageMeta']>
readonly definePayloadPlugin: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['definePayloadPlugin']>
readonly definePayloadReducer: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/payload')['definePayloadReducer']>
readonly definePayloadReviver: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/payload')['definePayloadReviver']>
readonly effect: UnwrapRef<typeof import('../../node_modules/vue')['effect']>
readonly effectScope: UnwrapRef<typeof import('../../node_modules/vue')['effectScope']>
readonly getAppManifest: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/manifest')['getAppManifest']>
readonly getCurrentInstance: UnwrapRef<typeof import('../../node_modules/vue')['getCurrentInstance']>
readonly getCurrentScope: UnwrapRef<typeof import('../../node_modules/vue')['getCurrentScope']>
readonly getRouteRules: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/manifest')['getRouteRules']>
readonly h: UnwrapRef<typeof import('../../node_modules/vue')['h']>
readonly hasInjectionContext: UnwrapRef<typeof import('../../node_modules/vue')['hasInjectionContext']>
readonly inject: UnwrapRef<typeof import('../../node_modules/vue')['inject']>
readonly injectHead: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['injectHead']>
readonly isNuxtError: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/error')['isNuxtError']>
readonly isPrerendered: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/payload')['isPrerendered']>
readonly isProxy: UnwrapRef<typeof import('../../node_modules/vue')['isProxy']>
readonly isReactive: UnwrapRef<typeof import('../../node_modules/vue')['isReactive']>
readonly isReadonly: UnwrapRef<typeof import('../../node_modules/vue')['isReadonly']>
readonly isRef: UnwrapRef<typeof import('../../node_modules/vue')['isRef']>
readonly isShallow: UnwrapRef<typeof import('../../node_modules/vue')['isShallow']>
readonly isVue2: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/compat/vue-demi')['isVue2']>
readonly isVue3: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/compat/vue-demi')['isVue3']>
readonly loadPayload: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/payload')['loadPayload']>
readonly markRaw: UnwrapRef<typeof import('../../node_modules/vue')['markRaw']>
readonly navigateTo: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['navigateTo']>
readonly nextTick: UnwrapRef<typeof import('../../node_modules/vue')['nextTick']>
readonly onActivated: UnwrapRef<typeof import('../../node_modules/vue')['onActivated']>
readonly onBeforeMount: UnwrapRef<typeof import('../../node_modules/vue')['onBeforeMount']>
readonly onBeforeRouteLeave: UnwrapRef<typeof import('../../node_modules/vue-router')['onBeforeRouteLeave']>
readonly onBeforeRouteUpdate: UnwrapRef<typeof import('../../node_modules/vue-router')['onBeforeRouteUpdate']>
readonly onBeforeUnmount: UnwrapRef<typeof import('../../node_modules/vue')['onBeforeUnmount']>
readonly onBeforeUpdate: UnwrapRef<typeof import('../../node_modules/vue')['onBeforeUpdate']>
readonly onDeactivated: UnwrapRef<typeof import('../../node_modules/vue')['onDeactivated']>
readonly onErrorCaptured: UnwrapRef<typeof import('../../node_modules/vue')['onErrorCaptured']>
readonly onMounted: UnwrapRef<typeof import('../../node_modules/vue')['onMounted']>
readonly onNuxtReady: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ready')['onNuxtReady']>
readonly onPrehydrate: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['onPrehydrate']>
readonly onRenderTracked: UnwrapRef<typeof import('../../node_modules/vue')['onRenderTracked']>
readonly onRenderTriggered: UnwrapRef<typeof import('../../node_modules/vue')['onRenderTriggered']>
readonly onScopeDispose: UnwrapRef<typeof import('../../node_modules/vue')['onScopeDispose']>
readonly onServerPrefetch: UnwrapRef<typeof import('../../node_modules/vue')['onServerPrefetch']>
readonly onUnmounted: UnwrapRef<typeof import('../../node_modules/vue')['onUnmounted']>
readonly onUpdated: UnwrapRef<typeof import('../../node_modules/vue')['onUpdated']>
readonly onWatcherCleanup: UnwrapRef<typeof import('../../node_modules/vue')['onWatcherCleanup']>
readonly prefetchComponents: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/preload')['prefetchComponents']>
readonly preloadComponents: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/preload')['preloadComponents']>
readonly preloadPayload: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/payload')['preloadPayload']>
readonly preloadRouteComponents: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/preload')['preloadRouteComponents']>
readonly prerenderRoutes: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['prerenderRoutes']>
readonly provide: UnwrapRef<typeof import('../../node_modules/vue')['provide']>
readonly proxyRefs: UnwrapRef<typeof import('../../node_modules/vue')['proxyRefs']>
readonly reactive: UnwrapRef<typeof import('../../node_modules/vue')['reactive']>
readonly readonly: UnwrapRef<typeof import('../../node_modules/vue')['readonly']>
readonly ref: UnwrapRef<typeof import('../../node_modules/vue')['ref']>
readonly refreshCookie: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/cookie')['refreshCookie']>
readonly refreshNuxtData: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/asyncData')['refreshNuxtData']>
readonly reloadNuxtApp: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/chunk')['reloadNuxtApp']>
readonly requestIdleCallback: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/compat/idle-callback')['requestIdleCallback']>
readonly resolveComponent: UnwrapRef<typeof import('../../node_modules/vue')['resolveComponent']>
readonly setInterval: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/compat/interval')['setInterval']>
readonly setPageLayout: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['setPageLayout']>
readonly setResponseStatus: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['setResponseStatus']>
readonly shallowReactive: UnwrapRef<typeof import('../../node_modules/vue')['shallowReactive']>
readonly shallowReadonly: UnwrapRef<typeof import('../../node_modules/vue')['shallowReadonly']>
readonly shallowRef: UnwrapRef<typeof import('../../node_modules/vue')['shallowRef']>
readonly showError: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/error')['showError']>
readonly toRaw: UnwrapRef<typeof import('../../node_modules/vue')['toRaw']>
readonly toRef: UnwrapRef<typeof import('../../node_modules/vue')['toRef']>
readonly toRefs: UnwrapRef<typeof import('../../node_modules/vue')['toRefs']>
readonly toValue: UnwrapRef<typeof import('../../node_modules/vue')['toValue']>
readonly triggerRef: UnwrapRef<typeof import('../../node_modules/vue')['triggerRef']>
readonly tryUseNuxtApp: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['tryUseNuxtApp']>
readonly unref: UnwrapRef<typeof import('../../node_modules/vue')['unref']>
readonly updateAppConfig: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/config')['updateAppConfig']>
readonly useAppConfig: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/config')['useAppConfig']>
readonly useAsyncData: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/asyncData')['useAsyncData']>
readonly useAttrs: UnwrapRef<typeof import('../../node_modules/vue')['useAttrs']>
readonly useAuth: UnwrapRef<typeof import('../../composables/useAuth')['useAuth']>
readonly useCookie: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/cookie')['useCookie']>
readonly useCssModule: UnwrapRef<typeof import('../../node_modules/vue')['useCssModule']>
readonly useCssVars: UnwrapRef<typeof import('../../node_modules/vue')['useCssVars']>
readonly useDialogPluginComponent: UnwrapRef<typeof import('quasar')['useDialogPluginComponent']>
readonly useError: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/error')['useError']>
readonly useFetch: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/fetch')['useFetch']>
readonly useFormChild: UnwrapRef<typeof import('quasar')['useFormChild']>
readonly useFormValidation: UnwrapRef<typeof import('../../composables/useFormValidation')['useFormValidation']>
readonly useHead: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useHead']>
readonly useHeadSafe: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useHeadSafe']>
readonly useHydration: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/hydrate')['useHydration']>
readonly useId: UnwrapRef<typeof import('../../node_modules/vue')['useId']>
readonly useInterval: UnwrapRef<typeof import('quasar')['useInterval']>
readonly useLazyAsyncData: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/asyncData')['useLazyAsyncData']>
readonly useLazyFetch: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/fetch')['useLazyFetch']>
readonly useLink: UnwrapRef<typeof import('../../node_modules/vue-router')['useLink']>
readonly useLoadingIndicator: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/loading-indicator')['useLoadingIndicator']>
readonly useMeta: UnwrapRef<typeof import('quasar')['useMeta']>
readonly useModel: UnwrapRef<typeof import('../../node_modules/vue')['useModel']>
readonly useNuxtApp: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['useNuxtApp']>
readonly useNuxtData: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/asyncData')['useNuxtData']>
readonly useNuxtDevTools: UnwrapRef<typeof import('../../node_modules/@nuxt/devtools/dist/runtime/use-nuxt-devtools')['useNuxtDevTools']>
readonly usePreviewMode: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/preview')['usePreviewMode']>
readonly useQuasar: UnwrapRef<typeof import('quasar')['useQuasar']>
readonly useRenderCache: UnwrapRef<typeof import('quasar')['useRenderCache']>
readonly useRequestEvent: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['useRequestEvent']>
readonly useRequestFetch: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['useRequestFetch']>
readonly useRequestHeader: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['useRequestHeader']>
readonly useRequestHeaders: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['useRequestHeaders']>
readonly useRequestURL: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/url')['useRequestURL']>
readonly useResponseHeader: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/ssr')['useResponseHeader']>
readonly useRoute: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['useRoute']>
readonly useRouteAnnouncer: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/route-announcer')['useRouteAnnouncer']>
readonly useRouter: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/router')['useRouter']>
readonly useRuntimeConfig: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/nuxt')['useRuntimeConfig']>
readonly useRuntimeHook: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/runtime-hook')['useRuntimeHook']>
readonly useScript: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScript']>
readonly useScriptClarity: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptClarity']>
readonly useScriptCloudflareWebAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptCloudflareWebAnalytics']>
readonly useScriptCrisp: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptCrisp']>
readonly useScriptDatabuddyAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptDatabuddyAnalytics']>
readonly useScriptEventPage: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptEventPage']>
readonly useScriptFathomAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptFathomAnalytics']>
readonly useScriptGoogleAdsense: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptGoogleAdsense']>
readonly useScriptGoogleAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptGoogleAnalytics']>
readonly useScriptGoogleMaps: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptGoogleMaps']>
readonly useScriptGoogleTagManager: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptGoogleTagManager']>
readonly useScriptHotjar: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptHotjar']>
readonly useScriptIntercom: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptIntercom']>
readonly useScriptLemonSqueezy: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptLemonSqueezy']>
readonly useScriptMatomoAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptMatomoAnalytics']>
readonly useScriptMetaPixel: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptMetaPixel']>
readonly useScriptNpm: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptNpm']>
readonly useScriptPayPal: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptPayPal']>
readonly useScriptPlausibleAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptPlausibleAnalytics']>
readonly useScriptRedditPixel: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptRedditPixel']>
readonly useScriptRybbitAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptRybbitAnalytics']>
readonly useScriptSegment: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptSegment']>
readonly useScriptSnapchatPixel: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptSnapchatPixel']>
readonly useScriptStripe: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptStripe']>
readonly useScriptTriggerConsent: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptTriggerConsent']>
readonly useScriptTriggerElement: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptTriggerElement']>
readonly useScriptUmamiAnalytics: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptUmamiAnalytics']>
readonly useScriptVimeoPlayer: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptVimeoPlayer']>
readonly useScriptXPixel: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptXPixel']>
readonly useScriptYouTubePlayer: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/script-stubs')['useScriptYouTubePlayer']>
readonly useSeoMeta: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useSeoMeta']>
readonly useServerHead: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useServerHead']>
readonly useServerHeadSafe: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useServerHeadSafe']>
readonly useServerSeoMeta: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/head')['useServerSeoMeta']>
readonly useShadowRoot: UnwrapRef<typeof import('../../node_modules/vue')['useShadowRoot']>
readonly useSlots: UnwrapRef<typeof import('../../node_modules/vue')['useSlots']>
readonly useSplitAttrs: UnwrapRef<typeof import('quasar')['useSplitAttrs']>
readonly useState: UnwrapRef<typeof import('../../node_modules/nuxt/dist/app/composables/state')['useState']>
readonly useTemplateRef: UnwrapRef<typeof import('../../node_modules/vue')['useTemplateRef']>
readonly useTick: UnwrapRef<typeof import('quasar')['useTick']>
readonly useTimeout: UnwrapRef<typeof import('quasar')['useTimeout']>
readonly useTransitionState: UnwrapRef<typeof import('../../node_modules/vue')['useTransitionState']>
readonly watch: UnwrapRef<typeof import('../../node_modules/vue')['watch']>
readonly watchEffect: UnwrapRef<typeof import('../../node_modules/vue')['watchEffect']>
readonly watchPostEffect: UnwrapRef<typeof import('../../node_modules/vue')['watchPostEffect']>
readonly watchSyncEffect: UnwrapRef<typeof import('../../node_modules/vue')['watchSyncEffect']>
readonly withCtx: UnwrapRef<typeof import('../../node_modules/vue')['withCtx']>
readonly withDirectives: UnwrapRef<typeof import('../../node_modules/vue')['withDirectives']>
readonly withKeys: UnwrapRef<typeof import('../../node_modules/vue')['withKeys']>
readonly withMemo: UnwrapRef<typeof import('../../node_modules/vue')['withMemo']>
readonly withModifiers: UnwrapRef<typeof import('../../node_modules/vue')['withModifiers']>
readonly withScopeId: UnwrapRef<typeof import('../../node_modules/vue')['withScopeId']>
}
}

7
Frontend-Learner/.nuxt/types/layouts.d.ts vendored Normal file
View file

@ -0,0 +1,7 @@
import type { ComputedRef, MaybeRef } from 'vue'
export type LayoutKey = "auth" | "default" | "landing"
declare module 'nuxt/app' {
interface PageMeta {
layout?: MaybeRef<LayoutKey | false> | ComputedRef<LayoutKey | false>
}
}

7
Frontend-Learner/.nuxt/types/middleware.d.ts vendored Normal file
View file

@ -0,0 +1,7 @@
import type { NavigationGuard } from 'vue-router'
export type MiddlewareKey = "auth"
declare module 'nuxt/app' {
interface PageMeta {
middleware?: MiddlewareKey | NavigationGuard | Array<MiddlewareKey | NavigationGuard>
}
}

14
Frontend-Learner/.nuxt/types/nitro-config.d.ts vendored Normal file
View file

@ -0,0 +1,14 @@
// Generated by nitro
// App Config
import type { Defu } from 'defu'
type UserAppConfig = Defu<{}, []>
declare module "nitropack/types" {
interface AppConfig extends UserAppConfig {}
}
export {}

141
Frontend-Learner/.nuxt/types/nitro-imports.d.ts vendored Normal file
View file

@ -0,0 +1,141 @@
declare global {
const __buildAssetsURL: typeof import('../../node_modules/@nuxt/nitro-server/dist/runtime/utils/paths').buildAssetsURL
const __publicAssetsURL: typeof import('../../node_modules/@nuxt/nitro-server/dist/runtime/utils/paths').publicAssetsURL
const appendCorsHeaders: typeof import('../../node_modules/h3').appendCorsHeaders
const appendCorsPreflightHeaders: typeof import('../../node_modules/h3').appendCorsPreflightHeaders
const appendHeader: typeof import('../../node_modules/h3').appendHeader
const appendHeaders: typeof import('../../node_modules/h3').appendHeaders
const appendResponseHeader: typeof import('../../node_modules/h3').appendResponseHeader
const appendResponseHeaders: typeof import('../../node_modules/h3').appendResponseHeaders
const assertMethod: typeof import('../../node_modules/h3').assertMethod
const cachedEventHandler: typeof import('../../node_modules/nitropack/dist/runtime/internal/cache').cachedEventHandler
const cachedFunction: typeof import('../../node_modules/nitropack/dist/runtime/internal/cache').cachedFunction
const callNodeListener: typeof import('../../node_modules/h3').callNodeListener
const clearResponseHeaders: typeof import('../../node_modules/h3').clearResponseHeaders
const clearSession: typeof import('../../node_modules/h3').clearSession
const createApp: typeof import('../../node_modules/h3').createApp
const createAppEventHandler: typeof import('../../node_modules/h3').createAppEventHandler
const createError: typeof import('../../node_modules/h3').createError
const createEvent: typeof import('../../node_modules/h3').createEvent
const createEventStream: typeof import('../../node_modules/h3').createEventStream
const createRouter: typeof import('../../node_modules/h3').createRouter
const defaultContentType: typeof import('../../node_modules/h3').defaultContentType
const defineAppConfig: typeof import('../../node_modules/@nuxt/nitro-server/dist/runtime/utils/config').defineAppConfig
const defineCachedEventHandler: typeof import('../../node_modules/nitropack/dist/runtime/internal/cache').defineCachedEventHandler
const defineCachedFunction: typeof import('../../node_modules/nitropack/dist/runtime/internal/cache').defineCachedFunction
const defineEventHandler: typeof import('../../node_modules/h3').defineEventHandler
const defineLazyEventHandler: typeof import('../../node_modules/h3').defineLazyEventHandler
const defineNitroErrorHandler: typeof import('../../node_modules/nitropack/dist/runtime/internal/error/utils').defineNitroErrorHandler
const defineNitroPlugin: typeof import('../../node_modules/nitropack/dist/runtime/internal/plugin').defineNitroPlugin
const defineNodeListener: typeof import('../../node_modules/h3').defineNodeListener
const defineNodeMiddleware: typeof import('../../node_modules/h3').defineNodeMiddleware
const defineRenderHandler: typeof import('../../node_modules/nitropack/dist/runtime/internal/renderer').defineRenderHandler
const defineRequestMiddleware: typeof import('../../node_modules/h3').defineRequestMiddleware
const defineResponseMiddleware: typeof import('../../node_modules/h3').defineResponseMiddleware
const defineRouteMeta: typeof import('../../node_modules/nitropack/dist/runtime/internal/meta').defineRouteMeta
const defineTask: typeof import('../../node_modules/nitropack/dist/runtime/internal/task').defineTask
const defineWebSocket: typeof import('../../node_modules/h3').defineWebSocket
const defineWebSocketHandler: typeof import('../../node_modules/h3').defineWebSocketHandler
const deleteCookie: typeof import('../../node_modules/h3').deleteCookie
const dynamicEventHandler: typeof import('../../node_modules/h3').dynamicEventHandler
const eventHandler: typeof import('../../node_modules/h3').eventHandler
const fetchWithEvent: typeof import('../../node_modules/h3').fetchWithEvent
const fromNodeMiddleware: typeof import('../../node_modules/h3').fromNodeMiddleware
const fromPlainHandler: typeof import('../../node_modules/h3').fromPlainHandler
const fromWebHandler: typeof import('../../node_modules/h3').fromWebHandler
const getCookie: typeof import('../../node_modules/h3').getCookie
const getHeader: typeof import('../../node_modules/h3').getHeader
const getHeaders: typeof import('../../node_modules/h3').getHeaders
const getMethod: typeof import('../../node_modules/h3').getMethod
const getProxyRequestHeaders: typeof import('../../node_modules/h3').getProxyRequestHeaders
const getQuery: typeof import('../../node_modules/h3').getQuery
const getRequestFingerprint: typeof import('../../node_modules/h3').getRequestFingerprint
const getRequestHeader: typeof import('../../node_modules/h3').getRequestHeader
const getRequestHeaders: typeof import('../../node_modules/h3').getRequestHeaders
const getRequestHost: typeof import('../../node_modules/h3').getRequestHost
const getRequestIP: typeof import('../../node_modules/h3').getRequestIP
const getRequestPath: typeof import('../../node_modules/h3').getRequestPath
const getRequestProtocol: typeof import('../../node_modules/h3').getRequestProtocol
const getRequestURL: typeof import('../../node_modules/h3').getRequestURL
const getRequestWebStream: typeof import('../../node_modules/h3').getRequestWebStream
const getResponseHeader: typeof import('../../node_modules/h3').getResponseHeader
const getResponseHeaders: typeof import('../../node_modules/h3').getResponseHeaders
const getResponseStatus: typeof import('../../node_modules/h3').getResponseStatus
const getResponseStatusText: typeof import('../../node_modules/h3').getResponseStatusText
const getRouteRules: typeof import('../../node_modules/nitropack/dist/runtime/internal/route-rules').getRouteRules
const getRouterParam: typeof import('../../node_modules/h3').getRouterParam
const getRouterParams: typeof import('../../node_modules/h3').getRouterParams
const getSession: typeof import('../../node_modules/h3').getSession
const getValidatedQuery: typeof import('../../node_modules/h3').getValidatedQuery
const getValidatedRouterParams: typeof import('../../node_modules/h3').getValidatedRouterParams
const handleCacheHeaders: typeof import('../../node_modules/h3').handleCacheHeaders
const handleCors: typeof import('../../node_modules/h3').handleCors
const isCorsOriginAllowed: typeof import('../../node_modules/h3').isCorsOriginAllowed
const isError: typeof import('../../node_modules/h3').isError
const isEvent: typeof import('../../node_modules/h3').isEvent
const isEventHandler: typeof import('../../node_modules/h3').isEventHandler
const isMethod: typeof import('../../node_modules/h3').isMethod
const isPreflightRequest: typeof import('../../node_modules/h3').isPreflightRequest
const isStream: typeof import('../../node_modules/h3').isStream
const isWebResponse: typeof import('../../node_modules/h3').isWebResponse
const lazyEventHandler: typeof import('../../node_modules/h3').lazyEventHandler
const nitroPlugin: typeof import('../../node_modules/nitropack/dist/runtime/internal/plugin').nitroPlugin
const parseCookies: typeof import('../../node_modules/h3').parseCookies
const promisifyNodeListener: typeof import('../../node_modules/h3').promisifyNodeListener
const proxyRequest: typeof import('../../node_modules/h3').proxyRequest
const readBody: typeof import('../../node_modules/h3').readBody
const readFormData: typeof import('../../node_modules/h3').readFormData
const readMultipartFormData: typeof import('../../node_modules/h3').readMultipartFormData
const readRawBody: typeof import('../../node_modules/h3').readRawBody
const readValidatedBody: typeof import('../../node_modules/h3').readValidatedBody
const removeResponseHeader: typeof import('../../node_modules/h3').removeResponseHeader
const runTask: typeof import('../../node_modules/nitropack/dist/runtime/internal/task').runTask
const sanitizeStatusCode: typeof import('../../node_modules/h3').sanitizeStatusCode
const sanitizeStatusMessage: typeof import('../../node_modules/h3').sanitizeStatusMessage
const sealSession: typeof import('../../node_modules/h3').sealSession
const send: typeof import('../../node_modules/h3').send
const sendError: typeof import('../../node_modules/h3').sendError
const sendIterable: typeof import('../../node_modules/h3').sendIterable
const sendNoContent: typeof import('../../node_modules/h3').sendNoContent
const sendProxy: typeof import('../../node_modules/h3').sendProxy
const sendRedirect: typeof import('../../node_modules/h3').sendRedirect
const sendStream: typeof import('../../node_modules/h3').sendStream
const sendWebResponse: typeof import('../../node_modules/h3').sendWebResponse
const serveStatic: typeof import('../../node_modules/h3').serveStatic
const setCookie: typeof import('../../node_modules/h3').setCookie
const setHeader: typeof import('../../node_modules/h3').setHeader
const setHeaders: typeof import('../../node_modules/h3').setHeaders
const setResponseHeader: typeof import('../../node_modules/h3').setResponseHeader
const setResponseHeaders: typeof import('../../node_modules/h3').setResponseHeaders
const setResponseStatus: typeof import('../../node_modules/h3').setResponseStatus
const splitCookiesString: typeof import('../../node_modules/h3').splitCookiesString
const toEventHandler: typeof import('../../node_modules/h3').toEventHandler
const toNodeListener: typeof import('../../node_modules/h3').toNodeListener
const toPlainHandler: typeof import('../../node_modules/h3').toPlainHandler
const toWebHandler: typeof import('../../node_modules/h3').toWebHandler
const toWebRequest: typeof import('../../node_modules/h3').toWebRequest
const unsealSession: typeof import('../../node_modules/h3').unsealSession
const updateSession: typeof import('../../node_modules/h3').updateSession
const useAppConfig: typeof import('../../node_modules/nitropack/dist/runtime/internal/config').useAppConfig
const useBase: typeof import('../../node_modules/h3').useBase
const useEvent: typeof import('../../node_modules/nitropack/dist/runtime/internal/context').useEvent
const useNitroApp: typeof import('../../node_modules/nitropack/dist/runtime/internal/app').useNitroApp
const useRuntimeConfig: typeof import('../../node_modules/nitropack/dist/runtime/internal/config').useRuntimeConfig
const useSession: typeof import('../../node_modules/h3').useSession
const useStorage: typeof import('../../node_modules/nitropack/dist/runtime/internal/storage').useStorage
const writeEarlyHints: typeof import('../../node_modules/h3').writeEarlyHints
}
export { useNitroApp } from 'nitropack/runtime/internal/app';
export { useRuntimeConfig, useAppConfig } from 'nitropack/runtime/internal/config';
export { defineNitroPlugin, nitroPlugin } from 'nitropack/runtime/internal/plugin';
export { defineCachedFunction, defineCachedEventHandler, cachedFunction, cachedEventHandler } from 'nitropack/runtime/internal/cache';
export { useStorage } from 'nitropack/runtime/internal/storage';
export { defineRenderHandler } from 'nitropack/runtime/internal/renderer';
export { defineRouteMeta } from 'nitropack/runtime/internal/meta';
export { getRouteRules } from 'nitropack/runtime/internal/route-rules';
export { useEvent } from 'nitropack/runtime/internal/context';
export { defineTask, runTask } from 'nitropack/runtime/internal/task';
export { defineNitroErrorHandler } from 'nitropack/runtime/internal/error/utils';
export { appendCorsHeaders, appendCorsPreflightHeaders, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, clearResponseHeaders, clearSession, createApp, createAppEventHandler, createError, createEvent, createEventStream, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, defineRequestMiddleware, defineResponseMiddleware, defineWebSocket, defineWebSocketHandler, deleteCookie, dynamicEventHandler, eventHandler, fetchWithEvent, fromNodeMiddleware, fromPlainHandler, fromWebHandler, getCookie, getHeader, getHeaders, getMethod, getProxyRequestHeaders, getQuery, getRequestFingerprint, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestPath, getRequestProtocol, getRequestURL, getRequestWebStream, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getRouterParam, getRouterParams, getSession, getValidatedQuery, getValidatedRouterParams, handleCacheHeaders, handleCors, isCorsOriginAllowed, isError, isEvent, isEventHandler, isMethod, isPreflightRequest, isStream, isWebResponse, lazyEventHandler, parseCookies, promisifyNodeListener, proxyRequest, readBody, readFormData, readMultipartFormData, readRawBody, readValidatedBody, removeResponseHeader, sanitizeStatusCode, sanitizeStatusMessage, sealSession, send, sendError, sendIterable, sendNoContent, sendProxy, sendRedirect, sendStream, sendWebResponse, serveStatic, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, setResponseStatus, splitCookiesString, toEventHandler, toNodeListener, toPlainHandler, toWebHandler, toWebRequest, unsealSession, updateSession, useBase, useSession, writeEarlyHints } from 'h3';
export { buildAssetsURL as __buildAssetsURL, publicAssetsURL as __publicAssetsURL } from 'C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/paths';
export { defineAppConfig } from 'C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/config';

6
Frontend-Learner/.nuxt/types/nitro-middleware.d.ts vendored Normal file
View file

@ -0,0 +1,6 @@
export type MiddlewareKey = "auth"
declare module 'nitropack' {
interface NitroRouteConfig {
appMiddleware?: MiddlewareKey | MiddlewareKey[] | Record<MiddlewareKey, boolean>
}
}

37
Frontend-Learner/.nuxt/types/nitro-nuxt.d.ts vendored Normal file
View file

@ -0,0 +1,37 @@
/// <reference path="app.config.d.ts" />
/// <reference path="runtime-config.d.ts" />
/// <reference types="C:/Users/Boybo/OneDrive/Desktop/e-learning/Frontend-Learner/node_modules/@nuxt/nitro-server/dist/index.mjs" />
/// <reference path="nitro-middleware.d.ts" />
/// <reference path="./schema.d.ts" />
import type { RuntimeConfig } from 'nuxt/schema'
import type { H3Event } from 'h3'
import type { LogObject } from 'consola'
import type { NuxtIslandContext, NuxtIslandResponse, NuxtRenderHTMLContext } from 'nuxt/app'
declare module 'nitropack' {
interface NitroRuntimeConfigApp {
buildAssetsDir: string
cdnURL: string
}
interface NitroRuntimeConfig extends RuntimeConfig {}
interface NitroRouteConfig {
ssr?: boolean
noScripts?: boolean
/** @deprecated Use `noScripts` instead */
experimentalNoScripts?: boolean
}
interface NitroRouteRules {
ssr?: boolean
noScripts?: boolean
/** @deprecated Use `noScripts` instead */
experimentalNoScripts?: boolean
appMiddleware?: Record<string, boolean>
}
interface NitroRuntimeHooks {
'dev:ssr-logs': (ctx: { logs: LogObject[], path: string }) => void | Promise<void>
'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event }) => void | Promise<void>
'render:island': (islandResponse: NuxtIslandResponse, context: { event: H3Event, islandContext: NuxtIslandContext }) => void | Promise<void>
}
}

14
Frontend-Learner/.nuxt/types/nitro-routes.d.ts vendored Normal file
View file

@ -0,0 +1,14 @@
// Generated by nitro
import type { Serialize, Simplify } from "nitropack/types";
declare module "nitropack/types" {
type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T
interface InternalApi {
'/__nuxt_error': {
'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../node_modules/@nuxt/nitro-server/dist/runtime/handlers/renderer').default>>>>
}
'/__nuxt_island/**': {
'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../server/#internal/nuxt/island-renderer').default>>>>
}
}
}
export {}

3
Frontend-Learner/.nuxt/types/nitro.d.ts vendored Normal file
View file

@ -0,0 +1,3 @@
/// <reference path="./nitro-routes.d.ts" />
/// <reference path="./nitro-config.d.ts" />
/// <reference path="./nitro-imports.d.ts" />

38
Frontend-Learner/.nuxt/types/plugins.d.ts vendored Normal file
View file

@ -0,0 +1,38 @@
// Generated by Nuxt'
import type { Plugin } from '#app'
type Decorate<T extends Record<string, any>> = { [K in keyof T as K extends string ? `$${K}` : never]: T[K] }
type InjectionType<A extends Plugin> = A extends {default: Plugin<infer T>} ? Decorate<T> : unknown
type NuxtAppInjections =
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/revive-payload.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/head/runtime/plugins/unhead.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/pages/runtime/plugins/router.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/browser-devtools-timing.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/dev-server-logs.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/navigation-repaint.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/check-outdated-build.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/revive-payload.server.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/chunk-reload.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/pages/runtime/plugins/prefetch.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/pages/runtime/plugins/check-if-page-unused.js")> &
InjectionType<typeof import("../../node_modules/@nuxt/devtools/dist/runtime/plugins/devtools.server.js")> &
InjectionType<typeof import("../../node_modules/@nuxt/devtools/dist/runtime/plugins/devtools.client.js")> &
InjectionType<typeof import("../../node_modules/nuxt-quasar-ui/dist/runtime/plugin.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/warn.dev.server.js")> &
InjectionType<typeof import("../../node_modules/nuxt/dist/app/plugins/check-if-layout-used.js")>
declare module '#app' {
interface NuxtApp extends NuxtAppInjections { }
interface NuxtAppLiterals {
pluginName: 'vue-devtools-client' | 'nuxt:revive-payload:client' | 'nuxt:head' | 'nuxt:router' | 'nuxt:browser-devtools-timing' | 'nuxt:revive-payload:server' | 'nuxt:chunk-reload' | 'nuxt:global-components' | 'nuxt:prefetch' | 'nuxt:checkIfPageUnused' | 'nuxt:checkIfLayoutUsed'
}
}
declare module 'vue' {
interface ComponentCustomProperties extends NuxtAppInjections { }
}
export { }

122
Frontend-Learner/.nuxt/types/schema.d.ts vendored Normal file
View file

@ -0,0 +1,122 @@
import { NuxtModule, ModuleDependencyMeta, RuntimeConfig } from '@nuxt/schema'
declare module '@nuxt/schema' {
interface ModuleDependencies {
["quasar"]?: ModuleDependencyMeta<typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxtjs/tailwindcss"]?: ModuleDependencyMeta<typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxt/devtools"]?: ModuleDependencyMeta<typeof import("@nuxt/devtools").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxt/telemetry"]?: ModuleDependencyMeta<typeof import("@nuxt/telemetry").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
}
interface NuxtOptions {
/**
* Configuration for `nuxt-quasar-ui`
*/
["quasar"]: typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxtjs/tailwindcss`
*/
["tailwindcss"]: typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxt/devtools`
*/
["devtools"]: typeof import("@nuxt/devtools").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxt/telemetry`
*/
["telemetry"]: typeof import("@nuxt/telemetry").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
}
interface NuxtConfig {
/**
* Configuration for `nuxt-quasar-ui`
*/
["quasar"]?: typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxtjs/tailwindcss`
*/
["tailwindcss"]?: typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxt/devtools`
*/
["devtools"]?: typeof import("@nuxt/devtools").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxt/telemetry`
*/
["telemetry"]?: typeof import("@nuxt/telemetry").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
modules?: (undefined | null | false | NuxtModule<any> | string | [NuxtModule | string, Record<string, any>] | ["nuxt-quasar-ui", Exclude<NuxtConfig["quasar"], boolean>] | ["@nuxtjs/tailwindcss", Exclude<NuxtConfig["tailwindcss"], boolean>] | ["@nuxt/devtools", Exclude<NuxtConfig["devtools"], boolean>] | ["@nuxt/telemetry", Exclude<NuxtConfig["telemetry"], boolean>])[],
}
}
declare module 'nuxt/schema' {
interface ModuleDependencies {
["quasar"]?: ModuleDependencyMeta<typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxtjs/tailwindcss"]?: ModuleDependencyMeta<typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxt/devtools"]?: ModuleDependencyMeta<typeof import("@nuxt/devtools").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
["@nuxt/telemetry"]?: ModuleDependencyMeta<typeof import("@nuxt/telemetry").default extends NuxtModule<infer O> ? O : Record<string, unknown>>
}
interface NuxtOptions {
/**
* Configuration for `nuxt-quasar-ui`
* @see https://www.npmjs.com/package/nuxt-quasar-ui
*/
["quasar"]: typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxtjs/tailwindcss`
* @see https://www.npmjs.com/package/@nuxtjs/tailwindcss
*/
["tailwindcss"]: typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxt/devtools`
* @see https://www.npmjs.com/package/@nuxt/devtools
*/
["devtools"]: typeof import("@nuxt/devtools").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
/**
* Configuration for `@nuxt/telemetry`
* @see https://www.npmjs.com/package/@nuxt/telemetry
*/
["telemetry"]: typeof import("@nuxt/telemetry").default extends NuxtModule<infer O, unknown, boolean> ? O : Record<string, any>
}
interface NuxtConfig {
/**
* Configuration for `nuxt-quasar-ui`
* @see https://www.npmjs.com/package/nuxt-quasar-ui
*/
["quasar"]?: typeof import("nuxt-quasar-ui").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxtjs/tailwindcss`
* @see https://www.npmjs.com/package/@nuxtjs/tailwindcss
*/
["tailwindcss"]?: typeof import("@nuxtjs/tailwindcss").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxt/devtools`
* @see https://www.npmjs.com/package/@nuxt/devtools
*/
["devtools"]?: typeof import("@nuxt/devtools").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
/**
* Configuration for `@nuxt/telemetry`
* @see https://www.npmjs.com/package/@nuxt/telemetry
*/
["telemetry"]?: typeof import("@nuxt/telemetry").default extends NuxtModule<infer O, unknown, boolean> ? Partial<O> : Record<string, any>
modules?: (undefined | null | false | NuxtModule<any> | string | [NuxtModule | string, Record<string, any>] | ["nuxt-quasar-ui", Exclude<NuxtConfig["quasar"], boolean>] | ["@nuxtjs/tailwindcss", Exclude<NuxtConfig["tailwindcss"], boolean>] | ["@nuxt/devtools", Exclude<NuxtConfig["devtools"], boolean>] | ["@nuxt/telemetry", Exclude<NuxtConfig["telemetry"], boolean>])[],
}
interface RuntimeConfig {
app: {
buildId: string,
baseURL: string,
buildAssetsDir: string,
cdnURL: string,
},
nitro: {
envPrefix: string,
},
}
interface PublicRuntimeConfig {
}
}
declare module 'vue' {
interface ComponentCustomProperties {
$config: RuntimeConfig
}
}

0
Frontend-Learner/.nuxt/types/vue-shim.d.ts vendored Normal file
View file

9
Frontend-Learner/.vscode/settings.json vendored Normal file
View file

@ -0,0 +1,9 @@
{
"css.lint.unknownAtRules": "ignore",
"cSpell.words": [
"Sarabun",
"Quasar",
"form-validation",
"glassmorphism"
]
}

5
Frontend-Learner/app.vue Normal file
View file

@ -0,0 +1,5 @@
<template>
<NuxtLayout>
<NuxtPage />
</NuxtLayout>
</template>

1096
Frontend-Learner/assets/css/main.css Normal file
View file

File diff suppressed because it is too large Load diff

45
Frontend-Learner/components/common/AppHeader.vue Normal file
View file

@ -0,0 +1,45 @@
<script setup lang="ts">
/**
* @file AppHeader.vue
* @description The main header for the authenticated application dashboard.
* Includes sidebar toggle, branding, search functionality, and user menu.
*/
defineProps<{
/** Controls visibility of the search bar */
showSearch?: boolean
}>()
const emit = defineEmits<{
/** Emitted when the hamburger menu is clicked */
toggleSidebar: []
}>()
</script>
<template>
<header class="app-header transition-colors" style="background-color: var(--bg-surface); border-bottom: 1px solid var(--border-color);">
<!-- Branding & Toggle -->
<div class="flex items-center gap-2">
<NuxtLink to="/dashboard" style="font-weight: 800; color: var(--primary); font-size: 20px;">
e-Learning
</NuxtLink>
</div>
<!-- Right Actions -->
<div class="flex items-center gap-4">
<!-- Search Bar (Optional) -->
<div v-if="showSearch !== false" class="relative hidden-mobile" style="width: 300px;">
<input
type="text"
class="input-field"
placeholder="ค้นหาคอร์ส..."
style="padding-left: 36px;"
>
<span style="position: absolute; left: 12px; top: 10px; color: var(--text-secondary);">🔍</span>
</div>
<!-- User Profile Dropdown -->
<UserMenu />
</div>
</header>
</template>

87
Frontend-Learner/components/common/FormInput.vue Normal file
View file

@ -0,0 +1,87 @@
<script setup lang="ts">
/**
* @file FormInput.vue
* @description Reusable input component with label, error handling, and support for disabled/required states.
*/
defineProps<{
modelValue: string
label: string
type?: string
placeholder?: string
error?: string
required?: boolean
disabled?: boolean
}>()
const emit = defineEmits<{
/** Update v-model value */
'update:modelValue': [value: string]
}>()
const updateValue = (event: Event) => {
emit('update:modelValue', (event.target as HTMLInputElement).value)
}
</script>
<template>
<div class="form-group" :class="{ 'has-error': error }">
<label class="input-label">
{{ label }}
<span v-if="required" class="required-mark">*</span>
</label>
<input
:type="type || 'text'"
:value="modelValue"
class="input-field"
:class="{ 'input-error': error }"
:placeholder="placeholder"
:disabled="disabled"
@input="updateValue"
>
<span v-if="error" class="error-message">
<span class="error-icon">⚠</span>
{{ error }}
</span>
</div>
</template>
<style scoped>
.form-group {
margin-bottom: 16px;
}
.required-mark {
color: var(--error);
margin-left: 2px;
}
.input-error {
border-color: var(--error) !important;
background-color: rgba(239, 68, 68, 0.05);
}
.input-error:focus {
outline-color: var(--error) !important;
}
.error-message {
display: flex;
align-items: center;
gap: 6px;
color: var(--error);
font-size: 12px;
margin-top: 6px;
animation: shake 0.3s ease-in-out;
}
.error-icon {
font-size: 14px;
}
@keyframes shake {
0%, 100% { transform: translateX(0); }
25% { transform: translateX(-4px); }
75% { transform: translateX(4px); }
}
</style>

198
Frontend-Learner/components/common/LandingFooter.vue Normal file
View file

@ -0,0 +1,198 @@
<script setup lang="ts">
/**
* @file LandingFooter.vue
* @description The main footer for the public landing pages.
* Contains site links, social media icons, and app download buttons.
*/
</script>
<template>
<footer class="landing-footer">
<div class="container">
<!-- Main Footer Grid -->
<div class="footer-grid">
<!-- Column 1: Brand & Social Media -->
<div class="footer-brand">
<div class="flex items-center gap-2 mb-4">
<div class="logo-box">E</div>
<span class="font-bold text-xl" style="color: white;">E-Learning System</span>
</div>
<p class="text-sm text-slate-400 mb-6">แพลตฟอร์มการเรียนออนไลน์สำหรับทักษแห่งอนาคต</p>
<div class="flex gap-4 social-icons">
<!-- Placeholder icons -->
<a href="#" class="social-icon">f</a>
<a href="#" class="social-icon">IG</a>
<a href="#" class="social-icon">Y</a>
</div>
</div>
<!-- Column 2: Services Links -->
<div class="footer-column">
<h4 class="font-bold mb-4" style="color: white;">บริการทั้งหมด</h4>
<ul class="footer-links">
<li><a href="#">คอร์สเรียนออนไลน์</a></li>
<li><a href="#">หลักสูตร Onsite</a></li>
<li><a href="#">หลักสูตร Class</a></li>
<li><a href="#">สำหรับองค์กร</a></li>
</ul>
</div>
<!-- Column 3: About Links -->
<div class="footer-column">
<h4 class="font-bold mb-4" style="color: white;">เกี่ยวกับเรา</h4>
<ul class="footer-links">
<li><a href="#">แพ็กเกจรายปี</a></li>
<li><a href="#">เส้นทางการเรียน</a></li>
<li><a href="#">วัดระดับทักษะ <span class="badge-beta">Beta</span></a></li>
<li><a href="#">บทความ</a></li>
<li><a href="#">คำถามที่พบบ่อย</a></li>
</ul>
</div>
<!-- Column 4: Join Us Links -->
<div class="footer-column">
<h4 class="font-bold mb-4" style="color: white;">ร่วมงานกับเรา</h4>
<ul class="footer-links">
<li><a href="#">สมัครงาน</a></li>
<li><a href="#">สมัครเป็น Affiliate</a></li>
<li><a href="#">สมัครเป็นผู้สอน</a></li>
<li><a href="#">เกี่ยวกับเรา</a></li>
<li><a href="#">ติดต่อเรา</a></li>
</ul>
</div>
<!-- Column 5: App Download & Contact -->
<div class="footer-column">
<h4 class="font-bold mb-4" style="color: white;">ดาวน์โหลดแอปพลิเคชัน</h4>
<div class="flex flex-col gap-2">
<button class="app-btn">
<span>🍎</span> App Store
</button>
<button class="app-btn">
<span>▶️</span> Google Play
</button>
</div>
<h4 class="font-bold mt-6 mb-4" style="color: white;">ปรึกษาการเรียน</h4>
<button class="btn btn-success w-full">
<span>💬</span> เพิ่มเพื่อน
</button>
</div>
</div>
<!-- Footer Bottom: Copyright & Legal -->
<div class="footer-bottom">
<p class="text-xs text-slate-400">© Copyright 2019-2026 LIKE ME X CO.,LTD All rights reserved.</p>
<div class="flex gap-4 text-xs text-slate-400">
<a href="#">ข้อตกลงการใช้บริการ</a>
<span>|</span>
<a href="#">นโยบายความเป็นส่วนตัว</a>
<span>|</span>
<a href="#">นโยบายการคืนเงิน</a>
</div>
</div>
</div>
</footer>
</template>
<style scoped>
/* Main Footer Structure */
.landing-footer {
background-color: #080b14; /* Deep Navy Background */
padding: 60px 0 20px;
border-top: 1px solid rgba(255, 255, 255, 0.05); /* Subtle border */
margin-top: auto;
color: #94a3b8;
}
.container {
max-width: 1200px;
margin: 0 auto;
padding: 0 24px;
}
/* 5-Column Grid Layout */
.footer-grid {
display: grid;
grid-template-columns: 2fr 1fr 1fr 1fr 1fr; /* First column is wider for branding */
gap: 40px;
margin-bottom: 60px;
}
.logo-box {
width: 32px;
height: 32px;
background: #eff6ff;
color: #3b82f6;
border-radius: 10px;
display: flex;
align-items: center;
justify-content: center;
font-weight: 800;
}
.footer-links li {
margin-bottom: 12px;
}
.footer-links a {
color: #94a3b8;
font-size: 14px;
transition: color 0.2s;
}
.footer-links a:hover {
color: #3b82f6;
}
.badge-beta {
background: #fee2e2;
color: #ef4444;
font-size: 10px;
padding: 2px 6px;
border-radius: 4px;
margin-left: 4px;
}
.app-btn {
background: #000;
color: white;
border: none;
border-radius: 8px;
padding: 8px 16px;
display: flex;
align-items: center;
gap: 8px;
font-size: 12px;
cursor: pointer;
}
.footer-bottom {
border-top: 1px solid rgba(255, 255, 255, 0.05);
padding-top: 20px;
display: flex;
justify-content: space-between;
flex-wrap: wrap;
gap: 16px;
}
/* Responsive Breakpoints */
@media (max-width: 1024px) {
.footer-grid {
grid-template-columns: repeat(2, 1fr);
}
}
@media (max-width: 640px) {
.footer-grid {
grid-template-columns: 1fr;
gap: 32px;
}
.footer-bottom {
flex-direction: column;
align-items: center;
text-align: center;
}
}
</style>

131
Frontend-Learner/components/common/LandingHeader.vue Normal file
View file

@ -0,0 +1,131 @@
<script setup lang="ts">
/**
* @file LandingHeader.vue
* @description The main header for the public landing pages.
* Features a transparent background that becomes solid/glass upon scrolling.
*/
// Track scrolling state to adjust header styling
const isScrolled = ref(false)
const { isAuthenticated } = useAuth()
onMounted(() => {
// Add scroll listener to toggle 'isScrolled' class
window.addEventListener('scroll', () => {
isScrolled.value = window.scrollY > 20
})
})
</script>
<template>
<!--
Header Container
- Transitions between transparent and glass effect based on scroll.
-->
<header
class="landing-header transition-all duration-300"
:class="[isScrolled ? 'h-16 glass-nav shadow-lg' : 'h-24 bg-transparent']"
>
<div class="container h-full flex items-center justify-between">
<!--
Left Section: Logo & Desktop Navigation
-->
<div class="flex items-center gap-12">
<!-- Logo -->
<NuxtLink to="/" class="flex items-center gap-3 group">
<div class="logo-box bg-blue-600 text-white font-black rounded-xl w-10 h-10 flex items-center justify-center shadow-lg shadow-blue-600/30 group-hover:scale-110 transition-transform">
E
</div>
<div class="flex flex-col">
<span class="font-black text-lg leading-none tracking-tight text-white group-hover:text-blue-400 transition-colors">E-Learning</span>
<span class="text-[10px] font-bold text-slate-500 uppercase tracking-[0.2em] leading-none mt-1">Platform</span>
</div>
</NuxtLink>
<!-- Desktop Links -->
<nav class="hidden md:block">
<ul class="flex items-center gap-8 text-sm font-bold">
<li>
<NuxtLink to="/browse" class="text-slate-400 hover:text-white transition-colors relative group">
คอร์สทั้งหมด
<span class="absolute -bottom-1 left-0 w-0 h-0.5 bg-blue-600 transition-all group-hover:w-full"/>
</NuxtLink>
</li>
<li>
<NuxtLink to="/browse/discovery" class="text-slate-400 hover:text-white transition-colors relative group">
ค้นพบ
<span class="absolute -bottom-1 left-0 w-0 h-0.5 bg-blue-600 transition-all group-hover:w-full"/>
</NuxtLink>
</li>
</ul>
</nav>
</div>
<!--
Right Section: Action Buttons (Login/Register or Dashboard)
-->
<div class="flex items-center gap-4">
<template v-if="!isAuthenticated">
<NuxtLink to="/auth/login" class="text-sm font-bold text-slate-300 hover:text-white px-4 py-2 transition-colors">เข้าสู่ระบบ</NuxtLink>
<NuxtLink to="/auth/register" class="btn-primary-premium shadow-lg shadow-blue-600/20">
เริ่มต้นใช้งาน
</NuxtLink>
</template>
<template v-else>
<NuxtLink to="/dashboard" class="btn-primary-premium shadow-lg shadow-blue-600/20">
เข้าสู่หน้าจัดการเรียน
</NuxtLink>
</template>
</div>
</div>
</header>
</template>
<style scoped>
/* Fixed header to stay on top */
.landing-header {
position: fixed;
top: 0;
left: 0;
width: 100%;
z-index: 100;
}
/* Glassmorphism Effect for Scrolled Header */
.glass-nav {
background: rgba(15, 23, 42, 0.8);
backdrop-filter: blur(12px);
border-bottom: 1px solid rgba(255, 255, 255, 0.05);
}
.container {
max-width: 1440px;
margin: 0 auto;
padding: 0 24px;
}
/* Premium Primary Button Styling */
.btn-primary-premium {
background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
color: white;
padding: 0.75rem 1.5rem;
border-radius: 0.75rem;
font-size: 0.875rem;
font-weight: 800;
transition: all 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
display: flex;
align-items: center;
justify-content: center;
}
.btn-primary-premium:hover {
transform: translateY(-2px);
box-shadow: 0 8px 20px -4px rgba(37, 99, 235, 0.5);
}
@media (max-width: 768px) {
.container {
padding: 0 16px;
}
}
</style>

108
Frontend-Learner/components/common/LoadingSkeleton.vue Normal file
View file

@ -0,0 +1,108 @@
<script setup lang="ts">
defineProps<{
type?: 'text' | 'avatar' | 'card' | 'button'
width?: string
height?: string
count?: number
}>()
</script>
<template>
<div class="skeleton-wrapper">
<template v-if="type === 'card'">
<div v-for="i in (count || 1)" :key="i" class="skeleton-card">
<div class="skeleton skeleton-image"/>
<div class="skeleton-content">
<div class="skeleton skeleton-title"/>
<div class="skeleton skeleton-text"/>
<div class="skeleton skeleton-text short"/>
</div>
</div>
</template>
<template v-else-if="type === 'avatar'">
<div class="skeleton skeleton-avatar"/>
</template>
<template v-else-if="type === 'button'">
<div class="skeleton skeleton-button" :style="{ width: width || '120px' }"/>
</template>
<template v-else>
<div
v-for="i in (count || 1)"
:key="i"
class="skeleton skeleton-text"
:style="{ width: width || '100%', height: height || '16px' }"
/>
</template>
</div>
</template>
<style scoped>
.skeleton-wrapper {
display: flex;
flex-direction: column;
gap: 12px;
}
.skeleton {
background: linear-gradient(90deg, var(--neutral-100) 25%, var(--neutral-200) 50%, var(--neutral-100) 75%);
background-size: 200% 100%;
animation: shimmer 1.5s infinite;
border-radius: 8px;
}
.skeleton-card {
background: var(--bg-surface);
border-radius: var(--radius-xl);
border: 1px solid var(--border-color);
overflow: hidden;
}
.skeleton-image {
height: 160px;
border-radius: 0;
}
.skeleton-content {
padding: 16px;
display: flex;
flex-direction: column;
gap: 8px;
}
.skeleton-title {
height: 20px;
width: 80%;
}
.skeleton-text {
height: 14px;
width: 100%;
}
.skeleton-text.short {
width: 60%;
}
.skeleton-avatar {
width: 48px;
height: 48px;
border-radius: 50%;
}
.skeleton-button {
height: 40px;
border-radius: 8px;
}
@keyframes shimmer {
0% {
background-position: -200% 0;
}
100% {
background-position: 200% 0;
}
}
</style>

68
Frontend-Learner/components/common/LoadingSpinner.vue Normal file
View file

@ -0,0 +1,68 @@
<script setup lang="ts">
defineProps<{
size?: 'sm' | 'md' | 'lg'
text?: string
fullPage?: boolean
}>()
</script>
<template>
<div :class="['loading-container', { 'loading-fullpage': fullPage }]">
<div :class="['spinner', size || 'md']"/>
<span v-if="text" class="loading-text">{{ text }}</span>
</div>
</template>
<style scoped>
.loading-container {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 12px;
padding: 20px;
}
.loading-fullpage {
position: fixed;
inset: 0;
background: rgba(255, 255, 255, 0.9);
z-index: 9999;
}
.spinner {
border: 3px solid var(--neutral-200);
border-top-color: var(--primary);
border-radius: 50%;
animation: spin 0.8s linear infinite;
}
.spinner.sm {
width: 20px;
height: 20px;
border-width: 2px;
}
.spinner.md {
width: 36px;
height: 36px;
border-width: 3px;
}
.spinner.lg {
width: 56px;
height: 56px;
border-width: 4px;
}
.loading-text {
color: var(--text-secondary);
font-size: 14px;
}
@keyframes spin {
to {
transform: rotate(360deg);
}
}
</style>

29
Frontend-Learner/components/common/MobileNav.vue Normal file
View file

@ -0,0 +1,29 @@
<script setup lang="ts">
const route = useRoute()
const navItems = [
{ to: '/dashboard', icon: '🏠', label: 'หน้าหลัก' },
{ to: '/browse/discovery', icon: '🔍', label: 'รายการคอร์ส' },
{ to: '/dashboard/my-courses', icon: '📚', label: 'คอร์สของฉัน' }
]
const isActive = (path: string) => {
if (path === '/') return route.path === '/'
return route.path.startsWith(path)
}
</script>
<template>
<nav class="mobile-nav">
<NuxtLink
v-for="item in navItems"
:key="item.to"
:to="item.to"
class="mobile-nav-item"
:class="{ active: isActive(item.to) }"
>
<span>{{ item.icon }}</span>
<span>{{ item.label }}</span>
</NuxtLink>
</nav>
</template>

237
Frontend-Learner/components/course/CourseCard.vue Normal file
View file

@ -0,0 +1,237 @@
<script setup lang="ts">
/**
* @file CourseCard.vue
* @description Card component for displaying course information.
* Supports various states: default, in-progress, completed.
* Handles action events (view, continue, certificate).
*/
interface CourseCardProps {
/** Course Title */
title: string
/** Difficulty Level (Beginner, Intermediate, etc.) */
level?: string
/** Visual type for level badge (color coding) */
levelType?: 'neutral' | 'warning' | 'success'
/** Course Price (e.g., 'Free', '฿990') */
price?: string
/** Short description */
description?: string
/** Rating score (e.g., '4.8') */
rating?: string
/** Number of lessons */
lessons?: string
/** Learning progress percentage (0-100) */
progress?: number
/** Whether the course is completed */
completed?: boolean
/** Show 'View Details' button */
showViewDetails?: boolean
/** Show 'Continue Learning' button */
showContinue?: boolean
/** Show 'Download Certificate' button (if completed) */
showCertificate?: boolean
/** Show 'Study Again' button (if completed) */
showStudyAgain?: boolean
/** URL for course thumbnail image */
image?: string
}
defineProps<CourseCardProps>()
const emit = defineEmits<{
viewDetails: []
continue: []
viewCertificate: []
}>()
</script>
<template>
<div class="card course-card group">
<!-- Thumbnail -->
<div class="thumbnail-wrapper relative h-44 overflow-hidden rounded-t-[1.5rem]">
<img
:src="image || 'https://images.unsplash.com/photo-1498050108023-c5249f4df085?w=400&q=80'"
:alt="title"
class="w-full h-full object-cover group-hover:scale-110 transition-transform duration-700"
>
<div v-if="completed" class="absolute inset-0 bg-emerald-600/60 backdrop-blur-[2px] flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity duration-300">
<span class="text-white bg-emerald-500 w-12 h-12 rounded-full flex items-center justify-center shadow-lg transform scale-0 group-hover:scale-100 transition-transform duration-500">
<svg xmlns="http://www.w3.org/2000/svg" class="h-6 w-6" fill="none" viewBox="20 20 24 24" stroke="currentColor">
<path stroke-linecap="round" stroke-linejoin="round" stroke-width="3" d="M5 13l4 4L19 7" />
</svg>
</span>
</div>
<!-- Badges overlay -->
<div class="absolute top-4 left-4 flex gap-2">
<span v-if="level" :class="`status-pill status-${levelType || 'neutral'} shadow-sm text-[9px]`">
{{ level }}
</span>
</div>
<div v-if="price" class="absolute top-4 right-4 glass px-3 py-1 rounded-full text-xs font-black text-white shadow-sm">
{{ price }}
</div>
</div>
<!-- Content -->
<div class="p-6 flex flex-col flex-1">
<!-- Title -->
<h3 class="font-black text-lg mb-2 line-clamp-1 text-slate-900 dark:text-white group-hover:text-blue-400 transition-colors">{{ title }}</h3>
<!-- Description -->
<div v-if="description" class="text-sm mb-6 line-clamp-2 leading-relaxed text-slate-600 dark:text-slate-400">{{ description }}</div>
<!-- Rating & Lessons -->
<div v-if="rating || lessons" class="flex items-center gap-4 text-[11px] font-bold mb-6 uppercase tracking-wider text-slate-500 dark:text-slate-400">
<span v-if="rating" class="flex items-center gap-1"><span class="text-amber-400 text-sm">★</span> {{ rating }}</span>
<span v-if="lessons" class="flex items-center gap-1"><span class="text-blue-400">📚</span> {{ lessons }} บทเรียน</span>
</div>
<!-- Progress Bar -->
<div v-if="progress !== undefined && !completed" class="mb-8 p-3 rounded-2xl" style="background-color: rgba(148, 163, 184, 0.1);">
<div class="flex justify-between items-center text-[10px] font-black uppercase tracking-widest mb-1.5">
<span style="color: var(--text-secondary);">Progress</span>
<span class="text-blue-600">{{ progress }}%</span>
</div>
<div class="w-full h-1.5 bg-slate-300 dark:bg-slate-700 rounded-full overflow-hidden">
<div class="h-full bg-blue-600 shadow-[0_0_10px_rgba(37,99,235,0.4)] rounded-full transition-all duration-1000" :style="{ width: `${progress}%` }"/>
</div>
</div>
<!-- Completed Badge -->
<div v-if="completed" class="mb-6">
<span class="status-pill status-success text-[10px] font-black uppercase tracking-widest flex items-center justify-center gap-2">
<span class="text-sm">✓</span> เรียนจบเรียบร้อย
</span>
</div>
<!-- Actions -->
<button v-if="showViewDetails" class="btn-premium-secondary w-full mt-auto" @click="emit('viewDetails')">
ดูรายละเอียด
</button>
<NuxtLink v-if="showContinue" to="/classroom/learning" class="btn-premium-primary w-full mt-auto shadow-lg shadow-blue-600/20">
เรียนต่อทันที
</NuxtLink>
<div v-if="completed && (showCertificate || showStudyAgain)" class="flex flex-col gap-2 mt-auto">
<NuxtLink v-if="showStudyAgain" to="/classroom/learning" class="btn-premium-secondary w-full">
ทบทวนบทเรียน
</NuxtLink>
<button v-if="showCertificate" class="btn-premium-success w-full shadow-lg shadow-emerald-600/20" @click="emit('viewCertificate')">
ดาวน์โหลดประกาศนียบัตร
</button>
</div>
</div>
</div>
</template>
<style scoped>
.course-card {
padding: 0;
border-radius: 2rem;
overflow: hidden;
display: flex;
flex-direction: column;
transition: all 0.4s cubic-bezier(0.34, 1.56, 0.64, 1);
background: var(--bg-surface);
border: 1px solid var(--border-color);
box-shadow: var(--shadow-md);
}
.course-card:hover {
transform: translateY(-8px);
box-shadow: var(--shadow-xl);
}
/* Remove explicit dark mode block as default variables handle it */
/* But keep specific tweaks if needed */
.btn-premium-primary {
background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
color: white;
padding: 0.875rem;
border-radius: 1rem;
font-weight: 800;
font-size: 0.875rem;
text-align: center;
transition: all 0.3s ease;
}
.btn-premium-primary:hover {
filter: brightness(110%);
transform: translateY(-2px);
}
.btn-premium-secondary {
background: transparent;
color: var(--text-main);
padding: 0.875rem;
border-radius: 1rem;
font-weight: 800;
font-size: 0.875rem;
border: 1px solid var(--border-color);
transition: all 0.3s ease;
}
.btn-premium-secondary:hover {
background: var(--bg-body);
border-color: #cbd5e1;
}
:global(.dark) .btn-premium-secondary {
background: rgba(255, 255, 255, 0.05);
color: #e2e8f0;
border-color: rgba(255, 255, 255, 0.1);
}
:global(.dark) .btn-premium-secondary:hover {
background: rgba(255, 255, 255, 0.1);
border-color: rgba(255, 255, 255, 0.2);
}
.btn-premium-success {
background: linear-gradient(135deg, #10b981 0%, #059669 100%);
color: white;
padding: 0.875rem;
border-radius: 1rem;
font-weight: 800;
font-size: 0.875rem;
transition: all 0.3s ease;
}
.glass {
background: rgba(255, 255, 255, 0.8);
backdrop-filter: blur(8px);
border: 1px solid rgba(229, 231, 235, 0.5);
}
:global(.dark) .glass {
background: rgba(15, 23, 42, 0.3);
border: 1px solid rgba(255, 255, 255, 0.1);
}
.status-pill {
@apply px-3 py-1 rounded-full font-black uppercase tracking-wider;
}
.status-success {
@apply bg-emerald-100 text-emerald-700;
}
.status-warning {
@apply bg-amber-100 text-amber-700;
}
.status-neutral {
@apply bg-slate-100 text-slate-700;
}
:global(.dark) .status-success {
@apply bg-emerald-900/40 text-emerald-300;
}
:global(.dark) .status-warning {
@apply bg-amber-900/40 text-amber-300;
}
:global(.dark) .status-neutral {
@apply bg-slate-700 text-slate-300;
}
</style>

100
Frontend-Learner/components/user/UserAvatar.vue Normal file
View file

@ -0,0 +1,100 @@
<script setup lang="ts">
const props = defineProps<{
size?: number | string
photoURL?: string
firstName?: string
lastName?: string
}>()
const imageError = ref(false)
const avatarSize = computed(() => {
const s = props.size || 32
if (typeof s === 'number') return `${s}px`
// If it's a string consisting only of digits, append px
if (/^\d+$/.test(s)) return `${s}px`
return s
})
const initials = computed(() => {
const getFirstChar = (name?: string) => {
if (!name) return ''
// For Thai names, if the first char is a leading vowel (เ แ โ ใ ไ), skip it to get the consonant
const leadingVowels = ['เ', 'แ', 'โ', 'ใ', 'ไ']
if (leadingVowels.includes(name.charAt(0)) && name.length > 1) {
return name.charAt(1)
}
return name.charAt(0)
}
const f = getFirstChar(props.firstName)
const l = getFirstChar(props.lastName)
return (f + l).toUpperCase()
})
const handleImageError = () => {
imageError.value = true
}
// Watch for photoURL changes to reset error state
watch(() => props.photoURL, () => {
imageError.value = false
})
</script>
<template>
<div
class="user-avatar"
:style="{ width: avatarSize, height: avatarSize }"
>
<img
v-if="photoURL && !imageError"
:src="photoURL"
class="avatar-img"
@error="handleImageError"
>
<div v-else class="avatar-initials">
{{ initials }}
</div>
</div>
</template>
<style scoped>
.user-avatar {
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
overflow: hidden;
background-color: var(--neutral-200);
color: var(--neutral-600);
font-weight: 700;
font-size: 13px;
flex-shrink: 0;
border: 1px solid var(--border-color);
}
.avatar-img {
width: 100%;
height: 100%;
object-fit: cover;
}
.avatar-initials {
width: 100%;
height: 100%;
display: flex;
align-items: center;
justify-content: center;
background: #3b82f6; /* Blue-500 to match theme */
color: #ffffff;
user-select: none;
font-size: 13px;
letter-spacing: 0.05em;
}
/* Specific styling for AppHeader integration */
:deep(.avatar-initials) {
text-transform: uppercase;
}
</style>

210
Frontend-Learner/components/user/UserMenu.vue Normal file
View file

@ -0,0 +1,210 @@
<script setup lang="ts">
/**
* @file UserMenu.vue
* @description User profile dropdown menu component.
* Features:
* - Displays user initials and info
* - Navigation links
* - Dark mode toggle
* - Logout functionality
* - Responsive positioning using Teleport
*/
import { ref, computed, onMounted } from 'vue'
import { useAuth } from '~/composables/useAuth'
const { currentUser, logout } = useAuth()
const isOpen = ref(false)
const isDarkMode = ref(false)
const menuRef = ref<HTMLDivElement | null>(null)
// Sync Dark Mode state on mount
onMounted(() => {
// Should default to light, so we ensure state matches.
if (document.documentElement.classList.contains('dark')) {
isDarkMode.value = true
}
})
// Position calculation for the dropdown
const menuPosition = ref({ top: '0px', right: '0px' })
// Computed property to display user initials (e.g. "JD" for John Doe)
const userInitials = computed(() => {
const f = currentUser.value.firstName?.charAt(0).toUpperCase() || ''
const l = currentUser.value.lastName?.charAt(0).toUpperCase() || ''
return f + l
})
const userName = computed(() => {
return `${currentUser.value.firstName} ${currentUser.value.lastName}`
})
// Navigation menu definition
const menuItems = [
{ label: 'หน้าหลัก', to: '/dashboard' },
{ label: 'รายการคอร์ส', to: '/browse/discovery' },
{ label: 'คอร์สของฉัน', to: '/dashboard/my-courses' },
{ label: 'ตั้งค่าบัญชี', to: '/dashboard/profile' }
]
const handleNavigate = (path: string) => {
navigateTo(path)
isOpen.value = false
}
const handleLogout = async () => {
await logout()
}
/**
* Toggles dark mode on the document element.
*/
const toggleDarkMode = () => {
isDarkMode.value = !isDarkMode.value
if (isDarkMode.value) {
document.documentElement.classList.add('dark')
} else {
document.documentElement.classList.remove('dark')
}
}
/**
* Calculates and updates the menu position relative to the button.
*/
const updateMenuPosition = () => {
if (menuRef.value) {
const rect = menuRef.value.getBoundingClientRect()
menuPosition.value = {
top: `${rect.bottom + 8}px`,
right: `${window.innerWidth - rect.right}px`
}
}
}
const toggleMenu = () => {
isOpen.value = !isOpen.value
if (isOpen.value) {
updateMenuPosition()
}
}
// Event listeners for closing menu on click outside and resizing
onMounted(() => {
const handleClickOutside = (e: MouseEvent) => {
if (isOpen.value && menuRef.value && !menuRef.value.contains(e.target as Node)) {
isOpen.value = false
}
}
document.addEventListener('click', handleClickOutside)
return () => {
document.removeEventListener('click', handleClickOutside)
}
})
onMounted(() => {
const handleResize = () => {
if (isOpen.value) {
updateMenuPosition()
}
}
window.addEventListener('resize', handleResize)
return () => {
window.removeEventListener('resize', handleResize)
}
})
</script>
<template>
<div ref="menuRef" class="relative">
<!-- Avatar Button -->
<button
class="flex items-center justify-center w-10 h-10 rounded-full bg-blue-500 text-white font-bold text-sm hover:bg-blue-600 transition-colors cursor-pointer ring-2 ring-blue-500/30"
:title="userName"
@click="toggleMenu"
>
{{ userInitials }}
</button>
<!-- Dropdown Menu - Teleport to body to avoid overflow-hidden -->
<Teleport to="body">
<Transition
enter-active-class="transition ease-out duration-100"
enter-from-class="transform opacity-0 scale-95"
enter-to-class="transform opacity-100 scale-100"
leave-active-class="transition ease-in duration-75"
leave-from-class="transform opacity-100 scale-100"
leave-to-class="transform opacity-0 scale-95"
>
<div
v-if="isOpen"
class="fixed rounded-2xl shadow-lg dark:shadow-2xl z-50 w-64 border overflow-hidden transition-colors"
style="background-color: var(--bg-surface); border-color: rgba(255,255,255,0.1);"
:style="{
top: menuPosition.top,
right: menuPosition.right
}"
>
<!-- Menu Items -->
<nav class="py-2">
<button
v-for="item in menuItems"
:key="item.label"
class="w-full px-6 py-3 text-left transition-colors text-sm font-medium hover:bg-slate-100 dark:hover:bg-white/10 text-slate-800 dark:text-white"
@click="handleNavigate(item.to)"
>
{{ item.label }}
</button>
</nav>
<!-- Dark Mode Toggle -->
<div class="px-6 py-3 border-slate-200 dark:border-slate-700">
<button
class="w-full flex items-center justify-between py-2"
@click="toggleDarkMode"
>
<span class="text-sm font-medium text-slate-800 dark:text-white">โหมดกลางคืน</span>
<div
:class="[
'relative inline-flex h-6 w-11 items-center rounded-full transition-colors',
isDarkMode ? 'bg-blue-600' : 'bg-slate-300'
]"
>
<span
:class="[
'inline-block h-4 w-4 transform rounded-full bg-white transition-transform',
isDarkMode ? 'translate-x-6' : 'translate-x-1'
]"
/>
</div>
</button>
</div>
<!-- Logout Button -->
<div class="px-6 py-3 border-t border-slate-200 dark:border-slate-700">
<button
class="w-full px-4 py-2 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 hover:bg-red-100 dark:hover:bg-red-900/40 rounded-lg font-medium transition-colors text-sm"
@click="handleLogout"
>
ออกจากระบบ
</button>
</div>
</div>
</Transition>
</Teleport>
<!-- Backdrop to close menu -->
<div
v-if="isOpen"
class="fixed inset-0 z-40"
@click="isOpen = false"
/>
</div>
</template>
<style scoped>
button {
transition: all 0.2s ease;
}
</style>

37
Frontend-Learner/composables/useAuth.ts Normal file
View file

@ -0,0 +1,37 @@
// Shared global state for current user
const currentUser = ref({
prefix: 'นาย',
firstName: 'สมชาย',
lastName: 'ใจดี',
email: 'student@example.com',
photoURL: '' // Set to URL if available
})
export const useAuth = () => {
const token = useCookie('auth_token', {
maxAge: 60 * 60 * 24 * 7, // 1 week
sameSite: 'lax',
secure: process.env.NODE_ENV === 'production'
})
const isAuthenticated = computed(() => !!token.value)
const login = (mockToken: string = 'demo-token') => {
token.value = mockToken
}
const logout = () => {
token.value = null
// Reset user photo if needed on logout
// currentUser.value.photoURL = ''
return navigateTo('/auth/login', { replace: true })
}
return {
isAuthenticated,
token,
currentUser,
login,
logout
}
}

91
Frontend-Learner/composables/useFormValidation.ts Normal file
View file

@ -0,0 +1,91 @@
export interface ValidationRule {
required?: boolean
minLength?: number
maxLength?: number
email?: boolean
pattern?: RegExp
match?: string
custom?: (value: string) => string | null
}
export interface FieldErrors {
[key: string]: string
}
export function useFormValidation() {
const errors = ref<FieldErrors>({})
const validateEmail = (email: string): boolean => {
const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
return re.test(email)
}
const validateField = (value: string, rules: ValidationRule, fieldName: string, formData?: Record<string, string>): string | null => {
if (rules.required && !value.trim()) {
return `กรุณากรอก${fieldName}`
}
if (rules.minLength && value.length < rules.minLength) {
return `${fieldName}ต้องมีอย่างน้อย ${rules.minLength} ตัวอักษร`
}
if (rules.maxLength && value.length > rules.maxLength) {
return `${fieldName}ต้องไม่เกิน ${rules.maxLength} ตัวอักษร`
}
if (rules.email && value && !validateEmail(value)) {
return 'รูปแบบอีเมลไม่ถูกต้อง'
}
if (rules.pattern && value && !rules.pattern.test(value)) {
return `${fieldName}รูปแบบไม่ถูกต้อง`
}
if (rules.match && formData && value !== formData[rules.match]) {
return 'รหัสผ่านไม่ตรงกัน'
}
if (rules.custom) {
return rules.custom(value)
}
return null
}
const validate = (
formData: Record<string, string>,
validationRules: Record<string, { rules: ValidationRule; label: string }>
): boolean => {
const newErrors: FieldErrors = {}
let isValid = true
for (const [fieldKey, config] of Object.entries(validationRules)) {
const error = validateField(formData[fieldKey] || '', config.rules, config.label, formData)
if (error) {
newErrors[fieldKey] = error
isValid = false
}
}
errors.value = newErrors
return isValid
}
const clearErrors = () => {
errors.value = {}
}
const clearFieldError = (field: string) => {
if (errors.value[field]) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete errors.value[field]
}
}
return {
errors,
validate,
clearErrors,
clearFieldError
}
}

197
Frontend-Learner/error.vue Normal file
View file

@ -0,0 +1,197 @@
<script setup lang="ts">
const props = defineProps({
error: {
type: Object,
default: null
}
})
useHead({
title: `${props.error?.statusCode || 'Error'} - e-Learning`
})
const handleError = () => {
clearError({ redirect: '/home' })
}
</script>
<template>
<div class="error-wrapper">
<!-- 404 Not Found -->
<div v-if="error?.statusCode === 404" class="error-content fade-in">
<div class="illustration-box">
<span class="emoji-large">🔭</span>
<div class="glow-effect primary"/>
</div>
<h1 class="error-code text-primary">404</h1>
<h2 class="error-title">ไม่พบหน้าที่คุณต้องการ</h2>
<p class="error-desc">
ขออภัย เราไม่พบหน้าที่คุณค้นหาในระบบ <br>
อาจเป็นเพราะลิงก์ผิดพลาด ลบไปแล้ว หรือคุณไม่มีสิทธิ์เข้าถึง
</p>
<div class="actions">
<button class="btn btn-primary" @click="handleError">
กลับสู่หน้าหลัก
</button>
</div>
</div>
<!-- 403 Forbidden / Other Errors -->
<div v-else class="error-content fade-in">
<div class="illustration-box">
<span class="emoji-large">🔐</span>
<div class="glow-effect error"/>
</div>
<h1 class="error-code text-error">{{ error?.statusCode || 'Oops' }}</h1>
<h2 class="error-title">
{{ error?.statusCode === 403 ? 'ไม่มีสิทธิ์เข้าถึง' : 'เกิดข้อผิดพลาดบางอย่าง' }}
</h2>
<p class="error-desc">
{{ error?.message || 'ขออภัย ระบบขัดข้องชั่วคราว กรุณาลองใหม่อีกครั้ง' }}
</p>
<div class="actions">
<NuxtLink to="/auth/login" class="btn btn-primary">
เข้าสู่ระบบ
</NuxtLink>
<button class="btn btn-outline" style="border-radius: 99px;" @click="handleError">
กลับสู่หน้าหลัก
</button>
</div>
</div>
</div>
</template>
<style>
/* Nuxt Error Page styles should not be scoped usually to affect the whole page */
:root {
--primary: #3b82f6;
--error: #ef4444;
--bg-body: #0f172a;
--text-main: #f1f5f9;
--text-secondary: #cbd5e1;
--neutral-100: #1e293b;
--border-color: #334155;
}
.error-wrapper {
min-height: 100vh;
width: 100%;
display: flex;
align-items: center;
justify-content: center;
background-color: var(--bg-body);
color: var(--text-main);
padding: 24px;
font-family: 'Inter', 'Prompt', 'Sarabun', sans-serif;
}
.error-content {
max-width: 600px;
width: 100%;
text-align: center;
display: flex;
flex-direction: column;
align-items: center;
}
.illustration-box {
position: relative;
width: 160px;
height: 160px;
display: flex;
align-items: center;
justify-content: center;
margin-bottom: 32px;
}
.emoji-large {
font-size: 80px;
position: relative;
z-index: 10;
}
.glow-effect {
position: absolute;
width: 120px;
height: 120px;
border-radius: 50%;
filter: blur(40px);
opacity: 0.2;
}
.glow-effect.primary {
background-color: var(--primary);
}
.glow-effect.error {
background-color: var(--error);
}
.error-code {
font-size: 80px;
font-weight: 900;
line-height: 1;
margin-bottom: 8px;
letter-spacing: -2px;
}
.text-primary { color: var(--primary); }
.text-error { color: var(--error); }
.error-title {
font-size: 32px;
font-weight: 800;
margin-bottom: 16px;
letter-spacing: -0.5px;
}
.error-desc {
font-size: 18px;
color: var(--text-secondary);
line-height: 1.6;
margin-bottom: 40px;
max-width: 480px;
}
.actions {
display: flex;
gap: 16px;
justify-content: center;
}
.btn {
height: 48px;
padding: 0 32px;
font-size: 16px;
border-radius: 99px;
display: flex;
align-items: center;
gap: 8px;
cursor: pointer;
border: none;
font-weight: 600;
transition: opacity 0.2s;
}
.btn:hover { opacity: 0.9; }
.btn-primary {
background-color: var(--primary);
color: white;
}
.btn-outline {
background: transparent;
border: 1px solid var(--border-color);
color: var(--text-main);
}
.fade-in {
animation: fadeIn 0.6s cubic-bezier(0.16, 1, 0.3, 1);
}
@keyframes fadeIn {
from { opacity: 0; transform: translateY(20px); scale: 0.95; }
to { opacity: 1; transform: translateY(0); scale: 1; }
}
</style>

8
Frontend-Learner/eslint.config.mjs Normal file
View file

@ -0,0 +1,8 @@
import { createConfigForNuxt } from '@nuxt/eslint-config/flat'
export default createConfigForNuxt().append({
rules: {
'vue/multi-word-component-names': 'off',
'vue/no-v-html': 'off'
}
})

6
Frontend-Learner/layouts/auth.vue Normal file
View file

@ -0,0 +1,6 @@
<template>
<!-- Auth Shell: Wrapper for authentication pages (Login, Register, etc.) -->
<div class="auth-shell dark">
<slot />
</div>
</template>

23
Frontend-Learner/layouts/default.vue Normal file
View file

@ -0,0 +1,23 @@
<script setup lang="ts">
/**
* @file default.vue
* @description Default application layout for authenticated users.
* Includes the AppHeader and MobileNav.
*/
</script>
<template>
<!-- App Shell: Main container with global background and text color -->
<div class="app-shell min-h-screen transition-colors duration-200" style="background-color: var(--bg-body); color: var(--text-main);">
<!-- Header -->
<AppHeader />
<!-- Main Content Area -->
<main class="app-main">
<slot />
</main>
<!-- Mobile Bottom Navigation (Visible only on small screens) -->
<MobileNav />
</div>
</template>

40
Frontend-Learner/layouts/landing.vue Normal file
View file

@ -0,0 +1,40 @@
<script setup lang="ts">
/**
* @file landing.vue
* @description Layout for the landing page (public facing).
* Applies a dark theme by default and includes the public header and footer.
*/
</script>
<template>
<!-- Landing Layout Container: Forces Dark Theme -->
<div class="landing-layout dark">
<LandingHeader />
<!-- Main Content Area: Grows to fill available space -->
<main class="flex-grow">
<slot />
</main>
<LandingFooter />
</div>
</template>
<style>
/*
Layout Styling:
- Flexbox column layout to stick footer to bottom.
- Dark background base.
*/
.landing-layout {
min-height: 100vh;
display: flex;
flex-direction: column;
background-color: #0f172a; /* Slate 900 */
color: #f1f5f9; /* Slate 100 */
}
.flex-grow {
flex-grow: 1;
}
</style>

28
Frontend-Learner/middleware/auth.ts Normal file
View file

@ -0,0 +1,28 @@
export default defineNuxtRouteMiddleware((to) => {
const { isAuthenticated } = useAuth()
// Pages that are accessible only when NOT logged in (Auth pages)
const authPages = [
'/auth/login',
'/auth/register',
'/auth/forgot-password',
'/auth/reset-password'
]
// Pages that are accessible as public landing
// Note: /courses and /discovery (now in browse/) might be public depending on logic,
// but let's assume browse pages are public or handled separately.
// For now, we list the root.
const publicPages = ['/', '/courses', '/browse', '/browse/discovery']
// 1. If user is authenticated and tries to access login/register (Keep landing page accessible)
if (isAuthenticated.value && authPages.includes(to.path)) {
return navigateTo('/dashboard', { replace: true })
}
// 2. If user is NOT authenticated and tries to access a page that has this middleware applied
// and is NOT one of the public or auth pages.
if (!isAuthenticated.value && !authPages.includes(to.path) && !publicPages.includes(to.path)) {
return navigateTo('/auth/login', { replace: true })
}
})

16
Frontend-Learner/node_modules/.bin/acorn generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../acorn/bin/acorn" "$@"
else
exec node "$basedir/../acorn/bin/acorn" "$@"
fi

17
Frontend-Learner/node_modules/.bin/acorn.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\acorn\bin\acorn" %*

28
Frontend-Learner/node_modules/.bin/acorn.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../acorn/bin/acorn" $args
} else {
& "$basedir/node$exe" "$basedir/../acorn/bin/acorn" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../acorn/bin/acorn" $args
} else {
& "node$exe" "$basedir/../acorn/bin/acorn" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/autoprefixer generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../autoprefixer/bin/autoprefixer" "$@"
else
exec node "$basedir/../autoprefixer/bin/autoprefixer" "$@"
fi

17
Frontend-Learner/node_modules/.bin/autoprefixer.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\autoprefixer\bin\autoprefixer" %*

28
Frontend-Learner/node_modules/.bin/autoprefixer.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
} else {
& "$basedir/node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
} else {
& "node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/baseline-browser-mapping generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
else
exec node "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
fi

17
Frontend-Learner/node_modules/.bin/baseline-browser-mapping.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\baseline-browser-mapping\dist\cli.js" %*

28
Frontend-Learner/node_modules/.bin/baseline-browser-mapping.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
} else {
& "node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/browserslist generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../browserslist/cli.js" "$@"
else
exec node "$basedir/../browserslist/cli.js" "$@"
fi

17
Frontend-Learner/node_modules/.bin/browserslist.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\browserslist\cli.js" %*

28
Frontend-Learner/node_modules/.bin/browserslist.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../browserslist/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../browserslist/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../browserslist/cli.js" $args
} else {
& "node$exe" "$basedir/../browserslist/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/crc32 generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../crc-32/bin/crc32.njs" "$@"
else
exec node "$basedir/../crc-32/bin/crc32.njs" "$@"
fi

17
Frontend-Learner/node_modules/.bin/crc32.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\crc-32\bin\crc32.njs" %*

28
Frontend-Learner/node_modules/.bin/crc32.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../crc-32/bin/crc32.njs" $args
} else {
& "$basedir/node$exe" "$basedir/../crc-32/bin/crc32.njs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../crc-32/bin/crc32.njs" $args
} else {
& "node$exe" "$basedir/../crc-32/bin/crc32.njs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/cssesc generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../cssesc/bin/cssesc" "$@"
else
exec node "$basedir/../cssesc/bin/cssesc" "$@"
fi

17
Frontend-Learner/node_modules/.bin/cssesc.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\cssesc\bin\cssesc" %*

28
Frontend-Learner/node_modules/.bin/cssesc.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../cssesc/bin/cssesc" $args
} else {
& "$basedir/node$exe" "$basedir/../cssesc/bin/cssesc" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../cssesc/bin/cssesc" $args
} else {
& "node$exe" "$basedir/../cssesc/bin/cssesc" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/detect-libc generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../detect-libc/bin/detect-libc.js" "$@"
else
exec node "$basedir/../detect-libc/bin/detect-libc.js" "$@"
fi

17
Frontend-Learner/node_modules/.bin/detect-libc.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\detect-libc\bin\detect-libc.js" %*

28
Frontend-Learner/node_modules/.bin/detect-libc.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args
} else {
& "$basedir/node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args
} else {
& "node$exe" "$basedir/../detect-libc/bin/detect-libc.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/devtools generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../@nuxt/devtools/cli.mjs" "$@"
else
exec node "$basedir/../@nuxt/devtools/cli.mjs" "$@"
fi

16
Frontend-Learner/node_modules/.bin/devtools-wizard generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../@nuxt/devtools-wizard/cli.mjs" "$@"
else
exec node "$basedir/../@nuxt/devtools-wizard/cli.mjs" "$@"
fi

17
Frontend-Learner/node_modules/.bin/devtools-wizard.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\@nuxt\devtools-wizard\cli.mjs" %*

28
Frontend-Learner/node_modules/.bin/devtools-wizard.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../@nuxt/devtools-wizard/cli.mjs" $args
} else {
& "$basedir/node$exe" "$basedir/../@nuxt/devtools-wizard/cli.mjs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../@nuxt/devtools-wizard/cli.mjs" $args
} else {
& "node$exe" "$basedir/../@nuxt/devtools-wizard/cli.mjs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

17
Frontend-Learner/node_modules/.bin/devtools.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\@nuxt\devtools\cli.mjs" %*

28
Frontend-Learner/node_modules/.bin/devtools.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../@nuxt/devtools/cli.mjs" $args
} else {
& "$basedir/node$exe" "$basedir/../@nuxt/devtools/cli.mjs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../@nuxt/devtools/cli.mjs" $args
} else {
& "node$exe" "$basedir/../@nuxt/devtools/cli.mjs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/esbuild generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../esbuild/bin/esbuild" "$@"
else
exec node "$basedir/../esbuild/bin/esbuild" "$@"
fi

17
Frontend-Learner/node_modules/.bin/esbuild.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\esbuild\bin\esbuild" %*

28
Frontend-Learner/node_modules/.bin/esbuild.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../esbuild/bin/esbuild" $args
} else {
& "$basedir/node$exe" "$basedir/../esbuild/bin/esbuild" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../esbuild/bin/esbuild" $args
} else {
& "node$exe" "$basedir/../esbuild/bin/esbuild" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/eslint generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../eslint/bin/eslint.js" "$@"
else
exec node "$basedir/../eslint/bin/eslint.js" "$@"
fi

17
Frontend-Learner/node_modules/.bin/eslint.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\eslint\bin\eslint.js" %*

28
Frontend-Learner/node_modules/.bin/eslint.ps1 generated vendored Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../eslint/bin/eslint.js" $args
} else {
& "$basedir/node$exe" "$basedir/../eslint/bin/eslint.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../eslint/bin/eslint.js" $args
} else {
& "node$exe" "$basedir/../eslint/bin/eslint.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
Frontend-Learner/node_modules/.bin/giget generated vendored Normal file
View file

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../giget/dist/cli.mjs" "$@"
else
exec node "$basedir/../giget/dist/cli.mjs" "$@"
fi

17
Frontend-Learner/node_modules/.bin/giget.cmd generated vendored Normal file
View file

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\giget\dist\cli.mjs" %*

Some files were not shown because too many files have changed in this diff Show more