repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/services/skills/skills.service.ts
|
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
// Rxjs
import { Observable } from 'rxjs';
// Model
import { Skill } from '../../models/skills/skill.model';
// Shared
import { APIResponse } from '../../../../shared/models/api-response.model';
// Env
import { environment } from '../../../../../environments/environment';
@Injectable()
export class SkillsService {
constructor(private httpClient: HttpClient) {}
getAllSkills(): Observable<APIResponse> {
return this.httpClient.get(`${environment.backendUrl}/api/v1/skills`);
}
getSkill(skillId: string): Observable<APIResponse> {
return this.httpClient.get(
`${environment.backendUrl}/api/v1/skills/${skillId}`
);
}
createSkill(skill: Skill): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.post<APIResponse>(
`${environment.backendUrl}/api/v1/skills`,
skill,
httpOptions
);
}
updateSkill(skillId: string, skillChanges: Skill): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.patch<APIResponse>(
`${environment.backendUrl}/api/v1/skills/${skillId}`,
skillChanges,
httpOptions
);
}
deleteSkill(skillId: string): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.delete<APIResponse>(
`${environment.backendUrl}/api/v1/skills/${skillId}`,
httpOptions
);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/services/auth/auth.service.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend<filename>src/app/auth/shared/services/auth/auth.service.ts
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
// RxJS
import { Observable, from, of, Subject } from 'rxjs';
import { tap } from 'rxjs/operators';
// Cookies
// import { CookieService } from 'ngx-cookie-service';
// Auth
import { User } from '../../models/user.model';
// Shared
import { APIResponse } from '../../../../shared/models/api-response.model';
// Env
import { environment } from '../../../../../environments/environment';
@Injectable()
export class AuthService {
/*
// authState -> Observable
// do -> create some side effect
auth$ = this.af.authState.pipe(tap(next => {
if (!next) {
this.store.set('user', null);
return;
}
// Create the user object
const user: User = {
email: next.email,
uid: next.uid,
authenticated: true
};
// Assign the user object to store
this.store.set('user', user);
}));
*/
constructor(private httpClient: HttpClient) {}
get user() {
return { email: '<EMAIL>' };
}
get authState() {
return { email: '<EMAIL>' };
}
createUser(email: string, password: string) {
return { email: '<EMAIL>' };
}
login(user: User): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.post<APIResponse>(
`${environment.backendUrl}/api/v1/users/login`,
user,
httpOptions
);
}
logout() {
return this.httpClient.get<APIResponse>(
`${environment.backendUrl}/api/v1/users/logout`,
{ withCredentials: true }
);
}
isLoggedIn(): Observable<APIResponse> {
return this.httpClient.get<APIResponse>(
`${environment.backendUrl}/api/v1/users/isLoggedIn`,
{ withCredentials: true }
);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/cv/components/nodejs/nodejs.component.ts
|
import { Component } from '@angular/core';
// CV
import { SkillItem } from 'src/app/website/shared/models/skill-item.model';
@Component({
selector: 'website-cv-skills-nodejs',
templateUrl: './nodejs.component.html',
styleUrls: ['./nodejs.component.scss']
})
export class NodeJSComponent {
items: SkillItem[];
constructor() {
this.items = [
{
name: 'Simple Web Server',
link:
'https://github.com/giorgiofederici/nodejs-knowledge/tree/master/01-web-server-simple'
},
{
name: 'Simple Routing',
link:
'https://github.com/giorgiofederici/nodejs-knowledge/tree/master/02-routing-simple'
}
];
}
test(event: any) {}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/contact/contact.module.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
// Routing
import { RouterModule, Routes } from '@angular/router';
// Forms
import { ReactiveFormsModule } from '@angular/forms';
// Font Awesome
import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
import { library } from '@fortawesome/fontawesome-svg-core';
import { faExclamation } from '@fortawesome/free-solid-svg-icons';
// Contact
import { ContactComponent } from './containers/contact/contact.component';
import { ContactFormComponent } from './components/contact-form/contact-form.component';
export const ROUTES: Routes = [{ path: '', component: ContactComponent }];
@NgModule({
imports: [
CommonModule,
RouterModule.forChild(ROUTES),
ReactiveFormsModule,
FontAwesomeModule
],
declarations: [ContactComponent, ContactFormComponent]
})
export class ContactModule {
constructor() {
library.add(faExclamation);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/shared/models/api-response.model.ts
|
import { User } from 'src/app/auth/shared/models/user.model';
export interface APIResponse {
status?: string;
results?: number;
data?: {
data?: any | any[];
user?: User;
};
}
|
giorgiofederici/giorgiofederici-frontend
|
src/environments/environment.prod.ts
|
<filename>src/environments/environment.prod.ts
import { baseEnv } from './environment.base';
export const environment = {
...baseEnv,
...{
production: true,
backendUrl: 'https://giorgiofederici.com:8443',
// UIsUrl: '',
domain: 'giorgiofederici.com'
}
};
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/actions/projects/projects.actions.ts
|
<gh_stars>0
// ngRx
import { Action } from '@ngrx/store';
import { Update } from '@ngrx/entity';
// Shared
import { Project } from '../../models/projects/project.model';
export enum ProjectsActionTypes {
// Get All Projects
GetAllProjects = '[Projects] Get All Projects',
GetAllProjectsSuccess = '[Projects/API] Get All Projects Success',
GetAllProjectsFailure = '[Projects/API] Get All Projects Failure',
// Get Project
GetProject = '[Projects] Get Project',
GetProjectSuccess = '[Projects/API] Get Project Success',
GetProjectFailure = '[Projects/API] Get Project Failure',
// Create Project
CreateProject = '[Projects] Create Project',
CreateProjectSuccess = '[Projects/API] Create Project Success',
CreateProjectFailure = '[Projects/API] Create Project Failure',
// Update Project
UpdateProject = '[Projects] Update Project',
UpdateProjectSuccess = '[Projects/API] Update Project Success',
UpdateProjectFailure = '[Projects/API] Update Project Failure',
// Delete Project
DeleteProject = '[Projects] Delete Project',
DeleteProjectSuccess = '[Projects/API] Delete Project Success',
DeleteProjectFailure = '[Projects/API] Delete Project Failure'
}
// Get All Projects
export class GetAllProjects implements Action {
readonly type = ProjectsActionTypes.GetAllProjects;
}
export class GetAllProjectsSuccess implements Action {
readonly type = ProjectsActionTypes.GetAllProjectsSuccess;
constructor(public payload: { projects: Project[] }) {}
}
export class GetAllProjectsFailure implements Action {
readonly type = ProjectsActionTypes.GetAllProjectsFailure;
constructor(public payload: { error: any }) {}
}
// Get Project
export class GetProject implements Action {
readonly type = ProjectsActionTypes.GetProject;
constructor(public payload: { projectId: string }) {}
}
export class GetProjectSuccess implements Action {
readonly type = ProjectsActionTypes.GetProjectSuccess;
constructor(public payload: { project: Project }) {}
}
export class GetProjectFailure implements Action {
readonly type = ProjectsActionTypes.GetProjectFailure;
constructor(public payload: { error: any }) {}
}
// Create Project
export class CreateProject implements Action {
readonly type = ProjectsActionTypes.CreateProject;
constructor(public payload: { project: Project }) {}
}
export class CreateProjectSuccess implements Action {
readonly type = ProjectsActionTypes.CreateProjectSuccess;
constructor(public payload: { project: Project }) {}
}
export class CreateProjectFailure implements Action {
readonly type = ProjectsActionTypes.CreateProjectFailure;
constructor(public payload: { error: any }) {}
}
// Update Project
export class UpdateProject implements Action {
readonly type = ProjectsActionTypes.UpdateProject;
constructor(public payload: { projectId: string; projectChanges: Project }) {}
}
export class UpdateProjectSuccess implements Action {
readonly type = ProjectsActionTypes.UpdateProjectSuccess;
constructor(public payload: { project: Update<Project> }) {}
}
export class UpdateProjectFailure implements Action {
readonly type = ProjectsActionTypes.UpdateProjectFailure;
constructor(public payload: { error: any }) {}
}
// Delete Project
export class DeleteProject implements Action {
readonly type = ProjectsActionTypes.DeleteProject;
constructor(public payload: { projectId: string }) {}
}
export class DeleteProjectSuccess implements Action {
readonly type = ProjectsActionTypes.DeleteProjectSuccess;
constructor(public payload: { projectId: string }) {}
}
export class DeleteProjectFailure implements Action {
readonly type = ProjectsActionTypes.DeleteProjectFailure;
constructor(public payload: { error: any }) {}
}
export type ProjectsActionsUnion =
| GetAllProjects
| GetAllProjectsSuccess
| GetAllProjectsFailure
| GetProject
| GetProjectSuccess
| GetProjectFailure
| CreateProject
| CreateProjectSuccess
| CreateProjectFailure
| UpdateProject
| UpdateProjectSuccess
| UpdateProjectFailure
| DeleteProject
| DeleteProjectSuccess
| DeleteProjectFailure;
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/actions/logout.actions.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend
import { Action } from '@ngrx/store';
export enum LogoutActionTypes {
Logout = '[Logout] Logout',
LogoutConfirmation = '[Logout] Logout Confirmation',
LogoutConfirmationDismiss = '[Logout] Logout Confirmation Dismiss'
}
export class Logout implements Action {
readonly type = LogoutActionTypes.Logout;
}
export class LogoutConfirmation implements Action {
readonly type = LogoutActionTypes.LogoutConfirmation;
}
export class LogoutConfirmationDismiss implements Action {
readonly type = LogoutActionTypes.LogoutConfirmationDismiss;
}
export type LogoutActionsUnion =
| Logout
| LogoutConfirmation
| LogoutConfirmationDismiss;
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/root/components/admin-header/admin-header.component.ts
|
import { Component, Input, EventEmitter, Output } from '@angular/core';
// Auth
import { User } from '../../../../auth/shared/models/user.model';
@Component({
selector: 'admin-header',
templateUrl: './admin-header.component.html',
styleUrls: ['./admin-header.component.scss']
})
export class AdminHeaderComponent {
@Input()
user: User;
@Input()
loggedIn: boolean;
@Output()
logout: EventEmitter<any> = new EventEmitter();
onLogout() {
this.logout.emit();
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/services/projects/projects.service.ts
|
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
// Rxjs
import { Observable } from 'rxjs';
// Model
import { Project } from '../../models/projects/project.model';
// Shared
import { APIResponse } from '../../../../shared/models/api-response.model';
// Env
import { environment } from '../../../../../environments/environment';
@Injectable()
export class ProjectsService {
constructor(private httpClient: HttpClient) {}
getAllProjects(): Observable<APIResponse> {
return this.httpClient.get(
`${environment.backendUrl}/api/v1/projects?sort=index`
);
}
getProject(projectId: string): Observable<APIResponse> {
return this.httpClient.get(
`${environment.backendUrl}/api/v1/projects/${projectId}`
);
}
createProject(project: Project): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.post<APIResponse>(
`${environment.backendUrl}/api/v1/projects`,
project,
httpOptions
);
}
updateProject(
projectId: string,
projectChanges: Project
): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.patch<APIResponse>(
`${environment.backendUrl}/api/v1/projects/${projectId}`,
projectChanges,
httpOptions
);
}
deleteProject(projectId: string): Observable<APIResponse> {
// With credentials set to true will add response cookie
const httpOptions = {
headers: new HttpHeaders({
'Content-Type': 'application/json'
}),
withCredentials: true
};
return this.httpClient.delete<APIResponse>(
`${environment.backendUrl}/api/v1/projects/${projectId}`,
httpOptions
);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/portfolio/components/portfolio-item/portfolio-item.component.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend<filename>src/app/website/portfolio/components/portfolio-item/portfolio-item.component.ts
import { Component, Input } from '@angular/core';
// Models
import { Project } from '../../../../admin/shared/models/projects/project.model';
@Component({
selector: 'website-portfolio-item',
templateUrl: './portfolio-item.component.html',
styleUrls: ['./portfolio-item.component.scss']
})
export class PortfolioItemComponent {
@Input() project: Project;
constructor() {}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/material/material.module.ts
|
<gh_stars>0
import { NgModule } from '@angular/core';
import { MatButtonModule, MatDialogModule } from '@angular/material';
@NgModule({
imports: [MatButtonModule, MatDialogModule],
exports: [MatButtonModule, MatDialogModule]
})
export class MaterialModule {}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/root/admin-root.module.ts
|
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
// Routing
import { RouterModule, Routes } from '@angular/router';
// Ng Bootstrap
import { NgbCollapseModule } from '@ng-bootstrap/ng-bootstrap';
// Font Awesome
import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
import { library } from '@fortawesome/fontawesome-svg-core';
import { faBars } from '@fortawesome/free-solid-svg-icons';
// Admin Root
import { AdminRootComponent } from './containers/admin-root/admin-root.component';
import { AdminHeaderComponent } from './components/admin-header/admin-header.component';
import { AdminNavItemComponent } from './components/admin-nav-item/admin-nav-item.component';
import { AdminSidebarComponent } from './components/admin-sidebar/admin-sidebar.component';
import { AdminFooterComponent } from './components/admin-footer/admin-footer.component';
export const ROUTES: Routes = [
{
path: '',
component: AdminRootComponent,
children: [
{ path: '', redirectTo: 'dashboard', pathMatch: 'full' },
{
path: 'dashboard',
loadChildren: '../dashboard/dashboard.module#DashboardModule'
},
{
path: 'skills',
loadChildren: '../skills/skills.module#SkillsModule'
}
]
}
];
@NgModule({
imports: [
CommonModule,
RouterModule.forChild(ROUTES),
NgbCollapseModule,
FontAwesomeModule
],
declarations: [
AdminRootComponent,
AdminHeaderComponent,
AdminNavItemComponent,
AdminSidebarComponent,
AdminFooterComponent
],
exports: []
})
export class AdminRootModule {
constructor() {
library.add(faBars);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/effects/projects/projects.effects.ts
|
<filename>src/app/admin/shared/effects/projects/projects.effects.ts
import { Injectable } from '@angular/core';
// Router
import { Router } from '@angular/router';
// RxJs
import { of } from 'rxjs';
import { catchError, map, switchMap, tap } from 'rxjs/operators';
// ngRx
import { Actions, Effect, ofType } from '@ngrx/effects';
// Admin Shared
import { ProjectsActions } from '../../actions/projects';
import { ProjectsService } from '../../services/projects/projects.service';
// Shared
import { APIResponse } from '../../../../shared/models/api-response.model';
@Injectable()
export class ProjectsEffects {
@Effect()
getAllProjects$ = this.actions$.pipe(
ofType(ProjectsActions.ProjectsActionTypes.GetAllProjects),
switchMap(() =>
this.projectsService.getAllProjects().pipe(
map((res: APIResponse) => {
const projects = res.data.data;
return new ProjectsActions.GetAllProjectsSuccess({ projects });
}),
catchError(error =>
of(new ProjectsActions.GetAllProjectsFailure({ error: error.error }))
)
)
)
);
@Effect()
getProject$ = this.actions$.pipe(
ofType(ProjectsActions.ProjectsActionTypes.GetProject),
map((action: ProjectsActions.GetProject) => action.payload.projectId),
switchMap(projectId =>
this.projectsService.getProject(projectId).pipe(
map((res: APIResponse) => {
const project = res.data.data;
return new ProjectsActions.GetProjectSuccess({ project });
}),
catchError(error =>
of(new ProjectsActions.GetProjectFailure({ error: error.error }))
)
)
)
);
@Effect()
createProject$ = this.actions$.pipe(
ofType(ProjectsActions.ProjectsActionTypes.CreateProject),
map((action: ProjectsActions.CreateProject) => action.payload.project),
switchMap(project =>
this.projectsService.createProject(project).pipe(
map((res: APIResponse) => {
const newProject = res.data.data;
return new ProjectsActions.CreateProjectSuccess({
project: newProject
});
}),
catchError(error =>
of(new ProjectsActions.CreateProjectFailure({ error: error.error }))
)
)
)
);
@Effect()
updateProject$ = this.actions$.pipe(
ofType(ProjectsActions.ProjectsActionTypes.UpdateProject),
map((action: ProjectsActions.UpdateProject) => action.payload),
switchMap(payload =>
this.projectsService
.updateProject(payload.projectId, payload.projectChanges)
.pipe(
map((res: APIResponse) => {
const updatedProject = res.data.data;
return new ProjectsActions.UpdateProjectSuccess({
project: updatedProject
});
}),
catchError(error =>
of(new ProjectsActions.UpdateProjectFailure({ error: error.error }))
)
)
)
);
@Effect()
deleteProject$ = this.actions$.pipe(
ofType(ProjectsActions.ProjectsActionTypes.DeleteProject),
map((action: ProjectsActions.DeleteProject) => action.payload.projectId),
switchMap(projectId =>
this.projectsService.deleteProject(projectId).pipe(
map((res: APIResponse) => {
return new ProjectsActions.DeleteProjectSuccess({
projectId
});
}),
catchError(error =>
of(new ProjectsActions.DeleteProjectFailure({ error: error.error }))
)
)
)
);
@Effect({ dispatch: false })
createProjectSuccess$ = this.actions$.pipe(
ofType(
ProjectsActions.ProjectsActionTypes.CreateProjectSuccess,
ProjectsActions.ProjectsActionTypes.UpdateProjectSuccess,
ProjectsActions.ProjectsActionTypes.DeleteProjectSuccess
),
tap(() => {
this.router.navigate(['/admin/projects']);
})
);
constructor(
private actions$: Actions,
private projectsService: ProjectsService,
private router: Router
) {}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/login/containers/login/login.component.ts
|
<gh_stars>0
import { Component } from '@angular/core';
// Forms
import { FormGroup } from '@angular/forms';
// RxJS
import { Store, select } from '@ngrx/store';
// Auth shared
import { User } from '../../../shared/models/user.model';
import * as fromAuth from '../../../shared/reducers';
import { LoginActions } from '../../../shared/actions';
@Component({
selector: 'admin-login',
template: `
<div>
<admin-auth-form (submitted)="loginUser($event)">
<h1>Login</h1>
<button type="submit">
Login
</button>
<div class="error" *ngIf="error">
{{ error }}
</div>
</admin-auth-form>
</div>
`
})
export class LoginComponent {
error: string;
constructor(private store: Store<fromAuth.State>) {}
async loginUser(event: FormGroup) {
const user: User = {
email: event.value.email,
password: event.value.password
};
this.store.dispatch(new LoginActions.Login({ user }));
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/contact/components/contact-form/contact-form.component.ts
|
import { Component, Output, EventEmitter } from '@angular/core';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';
import { ContactMessage } from '../../../shared/services/contact/contact.service';
@Component({
selector: 'website-contact-form',
templateUrl: './contact-form.component.html',
styleUrls: ['./contact-form.component.scss']
})
export class ContactFormComponent {
@Output()
send: EventEmitter<ContactMessage> = new EventEmitter<ContactMessage>();
form: FormGroup = this.fb.group({
firstName: ['', Validators.required],
lastName: ['', Validators.required],
email: ['', [Validators.required, Validators.email]],
message: ['', Validators.required]
});
constructor(
private fb: FormBuilder
) { }
get firstNameRequired(): boolean {
return (
this.form.get('firstName').hasError('required') &&
this.form.get('firstName').touched
);
}
get lastNameRequired(): boolean {
return (
this.form.get('lastName').hasError('required') &&
this.form.get('lastName').touched
);
}
get emailNotValid(): boolean {
return (
(this.form.get('email').hasError('required') || this.form.get('email').hasError('email')) &&
this.form.get('email').touched
);
}
get messageRequired(): boolean {
return (
this.form.get('message').hasError('required') &&
this.form.get('message').touched
);
}
sendMessage(): void {
if (this.form.valid) {
this.send.emit(this.form.value);
}
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/cv/containers/cv/cv.component.ts
|
import { Component, OnInit } from '@angular/core';
// Rxjs
import { Observable } from 'rxjs';
// ngRx
import { Store, select } from '@ngrx/store';
// Reducers
import * as fromSkills from '../../../../admin/shared/reducers/skills/skills.reducer';
// Actions
import { SkillsActions } from '../../../../admin/shared/actions/skills';
// Shared
import { Skill } from '../../../../admin/shared/models/skills/skill.model';
@Component({
selector: 'website-cv',
templateUrl: './cv.component.html',
styleUrls: ['./cv.component.scss']
})
export class CVComponent implements OnInit {
skills$: Observable<Skill[]>;
constructor(private store: Store<fromSkills.SkillsState>) {
this.skills$ = this.store.pipe(select(fromSkills.selectAllSkills));
}
ngOnInit() {
this.store.dispatch(new SkillsActions.GetAllSkills());
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/skills/containers/skills/skills.component.ts
|
<gh_stars>0
import { Component, OnInit } from '@angular/core';
// Rxjs
import { Observable } from 'rxjs';
// ngRx
import { Store, select } from '@ngrx/store';
// Reducers
import * as fromSkills from '../../../shared/reducers/skills/skills.reducer';
// Actions
import { SkillsActions } from '../../../shared/actions/skills';
// Shared
import { Skill } from '../../../shared/models/skills/skill.model';
@Component({
selector: 'admin-skills',
templateUrl: './skills.component.html',
styleUrls: ['skills.component.scss']
})
export class SkillsComponent implements OnInit {
skills$: Observable<Skill[]>;
loading$: Observable<boolean>;
error$: Observable<string>;
constructor(private store: Store<fromSkills.SkillsState>) {
this.skills$ = this.store.pipe(select(fromSkills.selectAllSkills));
this.loading$ = store.pipe(select(fromSkills.selectAllSkillsLoading));
this.error$ = store.pipe(select(fromSkills.selectAllSkillsError));
}
ngOnInit() {
this.store.dispatch(new SkillsActions.GetAllSkills());
}
removeSkill(event: Skill) {
this.store.dispatch(new SkillsActions.DeleteSkill({ skillId: event._id }));
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/root/components/admin-nav-item/admin-nav-item.component.ts
|
<filename>src/app/admin/root/components/admin-nav-item/admin-nav-item.component.ts
import { Component, Input, Output, EventEmitter, OnInit } from '@angular/core';
@Component({
selector: 'admin-nav-item',
templateUrl: './admin-nav-item.component.html',
styleUrls: ['./admin-nav-item.component.scss']
})
export class AdminNavItemComponent implements OnInit {
@Input() routerLink: string | any[];
@Input() disableActive: boolean;
@Output() navigate = new EventEmitter();
activeClass: string;
ngOnInit() {
this.activeClass = this.disableActive ? '' : 'active';
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/home/components/home-presentation/home-presentation.component.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend
import {
Component,
ChangeDetectionStrategy,
Output,
EventEmitter
} from '@angular/core';
@Component({
selector: 'website-home-presentation',
changeDetection: ChangeDetectionStrategy.OnPush,
templateUrl: './home-presentation.component.html',
styleUrls: ['./home-presentation.component.scss']
})
export class HomePresentationComponent {
@Output()
navigate = new EventEmitter();
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/shared.module.ts
|
import { NgModule, ModuleWithProviders } from '@angular/core';
import { CommonModule } from '@angular/common';
import { RouterModule } from '@angular/router';
// ngRx
import { StoreModule } from '@ngrx/store';
import { EffectsModule } from '@ngrx/effects';
// Components
import { ListItemComponent } from './components/list-item/list-item.component';
// Reducer
import { skillsReducer } from './reducers/skills/skills.reducer';
import { projectsReducer } from './reducers/projects/projects.reducer';
// Effects
import { SkillsEffects } from './effects/skills/skills.effects';
import { ProjectsEffects } from './effects/projects/projects.effects';
// Services
import { SkillsService } from './services/skills/skills.service';
import { ProjectsService } from './services/projects/projects.service';
// Resolvers
import { SkillResolver } from './resolvers/skills/skill.resolver';
import { ProjectResolver } from './resolvers/projects/project.resolver';
@NgModule({
imports: [
CommonModule,
RouterModule,
StoreModule.forFeature('skills', skillsReducer),
StoreModule.forFeature('projects', projectsReducer),
EffectsModule.forFeature([SkillsEffects, ProjectsEffects])
],
declarations: [ListItemComponent],
providers: [],
exports: [ListItemComponent]
})
export class SharedModule {
static forRoot(): ModuleWithProviders {
return {
ngModule: SharedModule,
providers: [
SkillsService,
SkillResolver,
ProjectsService,
ProjectResolver
]
};
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/effects/skills/skills.effects.ts
|
import { Injectable } from '@angular/core';
// Router
import { Router } from '@angular/router';
// RxJs
import { of } from 'rxjs';
import { catchError, map, switchMap, tap } from 'rxjs/operators';
// ngRx
import { Actions, Effect, ofType } from '@ngrx/effects';
// Admin Shared
import { SkillsActions } from '../../actions/skills';
import { SkillsService } from '../../services/skills/skills.service';
// Shared
import { APIResponse } from '../../../../shared/models/api-response.model';
@Injectable()
export class SkillsEffects {
@Effect()
getAllSkills$ = this.actions$.pipe(
ofType(SkillsActions.SkillsActionTypes.GetAllSkills),
switchMap(() =>
this.skillsService.getAllSkills().pipe(
map((res: APIResponse) => {
const skills = res.data.data;
return new SkillsActions.GetAllSkillsSuccess({ skills });
}),
catchError(error =>
of(new SkillsActions.GetAllSkillsFailure({ error: error.error }))
)
)
)
);
@Effect()
getSkill$ = this.actions$.pipe(
ofType(SkillsActions.SkillsActionTypes.GetSkill),
map((action: SkillsActions.GetSkill) => action.payload.skillId),
switchMap(skillId =>
this.skillsService.getSkill(skillId).pipe(
map((res: APIResponse) => {
const skill = res.data.data;
return new SkillsActions.GetSkillSuccess({ skill });
}),
catchError(error =>
of(new SkillsActions.GetSkillFailure({ error: error.error }))
)
)
)
);
@Effect()
createSkill$ = this.actions$.pipe(
ofType(SkillsActions.SkillsActionTypes.CreateSkill),
map((action: SkillsActions.CreateSkill) => action.payload.skill),
switchMap(skill =>
this.skillsService.createSkill(skill).pipe(
map((res: APIResponse) => {
const newSkill = res.data.data;
return new SkillsActions.CreateSkillSuccess({ skill: newSkill });
}),
catchError(error =>
of(new SkillsActions.CreateSkillFailure({ error: error.error }))
)
)
)
);
@Effect()
updateSkill$ = this.actions$.pipe(
ofType(SkillsActions.SkillsActionTypes.UpdateSkill),
map((action: SkillsActions.UpdateSkill) => action.payload),
switchMap(payload =>
this.skillsService
.updateSkill(payload.skillId, payload.skillChanges)
.pipe(
map((res: APIResponse) => {
const updatedSkill = res.data.data;
return new SkillsActions.UpdateSkillSuccess({
skill: updatedSkill
});
}),
catchError(error =>
of(new SkillsActions.UpdateSkillFailure({ error: error.error }))
)
)
)
);
@Effect()
deleteSkill$ = this.actions$.pipe(
ofType(SkillsActions.SkillsActionTypes.DeleteSkill),
map((action: SkillsActions.DeleteSkill) => action.payload.skillId),
switchMap(skillId =>
this.skillsService.deleteSkill(skillId).pipe(
map((res: APIResponse) => {
return new SkillsActions.DeleteSkillSuccess({
skillId
});
}),
catchError(error =>
of(new SkillsActions.DeleteSkillFailure({ error: error.error }))
)
)
)
);
@Effect({ dispatch: false })
createSkillSuccess$ = this.actions$.pipe(
ofType(
SkillsActions.SkillsActionTypes.CreateSkillSuccess,
SkillsActions.SkillsActionTypes.UpdateSkillSuccess,
SkillsActions.SkillsActionTypes.DeleteSkillSuccess
),
tap(() => {
this.router.navigate(['/admin/skills']);
})
);
constructor(
private actions$: Actions,
private skillsService: SkillsService,
private router: Router
) {}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/portfolio/containers/portfolio/portfolio.component.ts
|
import { Component, OnInit } from '@angular/core';
// Rxjs
import { Observable } from 'rxjs';
// ngRx
import { Store, select } from '@ngrx/store';
// Reducers
import * as fromProjects from '../../../../admin/shared/reducers/projects/projects.reducer';
// Actions
import { ProjectsActions } from '../../../../admin/shared/actions/projects';
// Shared
import { Project } from '../../../../admin/shared/models/projects/project.model';
@Component({
selector: 'website-portfolio',
templateUrl: './portfolio.component.html',
styleUrls: ['./portfolio.component.scss']
})
export class PortfolioComponent implements OnInit {
projects$: Observable<Project[]>;
constructor(private store: Store<fromProjects.ProjectsState>) {
this.projects$ = this.store.pipe(select(fromProjects.selectAllProjects));
}
ngOnInit() {
this.store.dispatch(new ProjectsActions.GetAllProjects());
}
placeholders(length: number) {
return Array(3 - (length % 3));
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/environments/environment.base.ts
|
export const baseEnv = {
production: false,
backendUrl: 'http://localhost:3000',
// UIsUrl: 'http://localhost:4200',
domain: 'localhost'
};
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/reducers/auth.reducer.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend
// Shared
import { LoginActions, LogoutActions, UserActions } from '../actions';
import { User } from '../models/user.model';
export interface State {
user: User | null;
}
export const initialState: State = {
user: null
};
export function reducer(
state = initialState,
action:
| LoginActions.LoginActionsUnion
| LogoutActions.LogoutActionsUnion
| UserActions.UserActionsUnion
| UserActions.IsLoggedIn
): State {
switch (action.type) {
case LoginActions.LoginActionTypes.LoginSuccess: {
return {
...state,
user: action.payload.user
};
}
case LogoutActions.LogoutActionTypes.Logout: {
return initialState;
}
case UserActions.UserActionTypes.Authenticated: {
return {
...state,
user: action.payload.user
};
}
case UserActions.UserActionTypes.NotAuthenticated: {
return initialState;
}
case UserActions.UserActionTypes.AuthenticationError: {
return initialState;
}
default: {
return state;
}
}
}
export const getUser = (state: State) => state.user;
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/root/containers/admin-root/admin-root.component.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend
import { Component, OnInit } from '@angular/core';
// RxJS
import { Observable } from 'rxjs';
// NgRx
import { Store, select } from '@ngrx/store';
// Auth
import * as fromAuth from '../../../../auth/shared/reducers';
import { User } from '../../../../auth/shared/models/user.model';
import { LogoutActions } from 'src/app/auth/shared/actions';
@Component({
selector: 'admin-root',
templateUrl: './admin-root.component.html',
styleUrls: ['admin-root.component.scss']
})
export class AdminRootComponent implements OnInit {
user$: Observable<User>;
loggedIn$: Observable<boolean>;
constructor(
private store: Store<fromAuth.State>
) { }
ngOnInit() {
this.user$ = this.store.pipe(select(fromAuth.getUser));
this.loggedIn$ = this.store.pipe(select(fromAuth.getLoggedIn));
}
onLogout() {
this.store.dispatch(new LogoutActions.LogoutConfirmation());
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/cv/components/cv-timeline/cv-timeline.component.ts
|
import { Component } from '@angular/core';
@Component({
selector: 'website-cv-timeline',
templateUrl: './cv-timeline.component.html',
styleUrls: ['./cv-timeline.component.scss']
})
export class CVTimelineComponent { }
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/root/components/website-nav-item/website-nav-item.component.ts
|
<gh_stars>0
import { Component, Input, Output, EventEmitter } from '@angular/core';
@Component({
selector: 'website-nav-item',
templateUrl: './website-nav-item.component.html',
styleUrls: ['./website-nav-item.component.scss']
})
export class WebsiteNavItemComponent {
@Input() routerLink: string | any[] = '/';
@Output() navigate = new EventEmitter();
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/contact/containers/contact/contact.component.ts
|
import { Component } from '@angular/core';
import { ContactService, ContactMessage } from 'src/app/website/shared/services/contact/contact.service';
@Component({
selector: 'website-contact',
templateUrl: './contact.component.html',
styleUrls: ['./contact.component.scss']
})
export class ContactComponent {
constructor(
private contactService: ContactService
) { }
sendMessage(event: ContactMessage): void {
this.contactService.sendMessage(event);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/cv/cv.module.ts
|
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
// Routing
import { RouterModule, Routes } from '@angular/router';
// Font Awesome
import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
import { library } from '@fortawesome/fontawesome-svg-core';
import {
faBriefcase,
faUniversity,
faExternalLinkAlt
} from '@fortawesome/free-solid-svg-icons';
import {
faGithub,
faTwitter,
faLinkedin,
faInstagram
} from '@fortawesome/free-brands-svg-icons';
// CV
import { CVComponent } from './containers/cv/cv.component';
import { CVTimelineComponent } from './components/cv-timeline/cv-timeline.component';
import { CVSkillsComponent } from './components/cv-skills/cv-skills.component';
import { NodeJSComponent } from './components/nodejs/nodejs.component';
// Shared
import { SharedModule } from '../shared/shared.module';
import { SharedModule as AdminSharedModule } from '../../admin/shared/shared.module';
export const ROUTES: Routes = [
{ path: '', component: CVComponent },
{ path: 'nodejs', component: NodeJSComponent }
];
@NgModule({
imports: [
CommonModule,
RouterModule.forChild(ROUTES),
FontAwesomeModule,
SharedModule,
AdminSharedModule.forRoot()
],
declarations: [
CVComponent,
CVTimelineComponent,
CVSkillsComponent,
NodeJSComponent
]
})
export class CVModule {
constructor() {
library.add(
faBriefcase,
faUniversity,
faGithub,
faTwitter,
faLinkedin,
faInstagram,
faExternalLinkAlt
);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/shared/shared.module.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend<gh_stars>0
import { NgModule, ModuleWithProviders } from '@angular/core';
import { CommonModule } from '@angular/common';
// Router
import { RouterModule } from '@angular/router';
// Contact
import { ContactService } from './services/contact/contact.service';
// Components
import { ListItemComponent } from './components/list-item/list-item.component';
@NgModule({
imports: [CommonModule, RouterModule],
declarations: [ListItemComponent],
providers: [],
exports: [ListItemComponent]
})
export class SharedModule {
static forRoot(): ModuleWithProviders {
return {
ngModule: SharedModule,
providers: [ContactService]
};
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/resolvers/projects/project.resolver.ts
|
import { Injectable } from '@angular/core';
import {
ActivatedRouteSnapshot,
Resolve,
RouterStateSnapshot
} from '@angular/router';
// RxJS
import { Observable } from 'rxjs';
import { filter, first, tap } from 'rxjs/operators';
// ngRx
import { select, Store } from '@ngrx/store';
// Reducer
import * as fromProjects from '../../reducers/projects/projects.reducer';
// Actions
import { ProjectsActions } from '../../actions/projects/index';
// Model
import { Project } from '../../models/projects/project.model';
// Service
import { ProjectsService } from '../../services/projects/projects.service';
export class ProjectResolver implements Resolve<Project> {
constructor(
private store: Store<fromProjects.ProjectsState>,
private projectsService: ProjectsService
) {}
resolve(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot
): Observable<Project> {
const projectId = route.params.id;
return this.store.pipe(
select(fromProjects.selectProjectById(projectId)),
tap(project => {
if (!project) {
this.store.dispatch(new ProjectsActions.GetProject({ projectId }));
}
}),
filter(project => !!project),
first()
);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/effects/auth.effects.ts
|
<filename>src/app/auth/shared/effects/auth.effects.ts
import { Injectable } from '@angular/core';
// Router
import { Router } from '@angular/router';
// RxJs
import { of } from 'rxjs';
import { catchError, exhaustMap, map, tap, switchMap } from 'rxjs/operators';
// ngRx
import { Actions, Effect, ofType } from '@ngrx/effects';
// Material
import { MatDialog } from '@angular/material';
// Auth
import { LoginActions, LogoutActions, UserActions } from '../actions';
import { User } from '../models/user.model';
import { AuthService } from '../services/auth/auth.service';
import { LogoutConfirmationDialogComponent } from '../../logout/components/logout-confirmation-dialog/logout-confirmation-dialog.component';
// Shared
import { APIResponse } from '../../../shared/models/api-response.model';
@Injectable()
export class AuthEffects {
@Effect()
login$ = this.actions$.pipe(
ofType(LoginActions.LoginActionTypes.Login),
map((action: LoginActions.Login) => action.payload.user),
switchMap((payload: User) => {
return this.authService.login(payload);
}),
map((res: APIResponse) => {
const user = res.data.user;
return new LoginActions.LoginSuccess({ user });
}),
catchError(error => of(new LoginActions.LoginFailure({ error })))
);
@Effect({ dispatch: false })
loginSuccess$ = this.actions$.pipe(
ofType(LoginActions.LoginActionTypes.LoginSuccess),
tap(() => this.router.navigate(['/admin/dashboard']))
);
@Effect({ dispatch: false })
loginRedirect$ = this.actions$.pipe(
ofType(
LoginActions.LoginActionTypes.LoginRedirect,
LogoutActions.LogoutActionTypes.Logout
),
tap(authed => {
this.router.navigate(['/login']);
})
);
@Effect()
logoutConfirmation$ = this.actions$.pipe(
ofType(LogoutActions.LogoutActionTypes.LogoutConfirmation),
exhaustMap(() => {
const dialogRef = this.dialog.open<
LogoutConfirmationDialogComponent,
undefined,
boolean
>(LogoutConfirmationDialogComponent);
return dialogRef.afterClosed();
}),
map(result =>
result
? new LogoutActions.Logout()
: new LogoutActions.LogoutConfirmationDismiss()
)
);
@Effect({ dispatch: false })
logout$ = this.actions$.pipe(
ofType(LogoutActions.LogoutActionTypes.Logout),
switchMap(() => this.authService.logout()),
map(() => new LoginActions.LoginRedirect()),
catchError(error => of(new UserActions.AuthenticationError({ error }))) // TODO
);
@Effect()
getUser$ = this.actions$.pipe(
ofType(UserActions.UserActionTypes.GetUser),
map((action: UserActions.GetUser) => action.payload),
switchMap(payload => of(true)),
// delay(2000) // delay to show loading spinner, delete me!
map((auth: any) => {
if (auth) {
/// User logged in
const user: User = {
email: auth.email
};
return new UserActions.Authenticated({ user });
} else {
/// User not logged in
return new UserActions.NotAuthenticated();
}
}),
catchError(error => of(new UserActions.AuthenticationError({ error })))
);
@Effect()
isLoggedIn$ = this.actions$.pipe(
ofType(UserActions.UserActionTypes.IsLoggedIn),
map((action: UserActions.IsLoggedIn) => action.payload),
switchMap(payload => {
return this.authService.isLoggedIn();
}),
map((res: APIResponse) => {
if (res.data.user) {
// User logged in
const user = res.data.user;
return new UserActions.Authenticated({ user });
} else {
// User not logged in
return new LoginActions.LoginRedirect();
}
}),
catchError(error => of(new LoginActions.LoginRedirect()))
);
constructor(
private actions$: Actions,
private authService: AuthService,
private router: Router,
private dialog: MatDialog
) {}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/reducers/index.ts
|
<filename>src/app/auth/shared/reducers/index.ts
// RxJS
import {
createSelector,
createFeatureSelector,
ActionReducerMap
} from '@ngrx/store';
// Shared
import * as fromRoot from '../../../root/reducers';
import * as fromAuth from '../reducers/auth.reducer';
import * as fromLogin from '../reducers/login.reducer';
import { LoginActions } from '../actions';
export interface AuthState {
status: fromAuth.State;
login: fromLogin.State;
}
export interface State extends fromRoot.State {
auth: AuthState;
}
export const reducers: ActionReducerMap<
AuthState,
LoginActions.LoginActionsUnion
> = {
status: fromAuth.reducer,
login: fromLogin.reducer
};
export const selectAuthState = createFeatureSelector<State, AuthState>('auth');
export const selectAuthStatusState = createSelector(
selectAuthState,
(state: AuthState) => state.status
);
export const getUser = createSelector(
selectAuthStatusState,
fromAuth.getUser
);
export const getLoggedIn = createSelector(
getUser,
user => !!user
);
export const selectLoginState = createSelector(
selectAuthState,
(state: AuthState) => state.login
);
export const getLoginError = createSelector(
selectLoginState,
fromLogin.getError
);
export const getLoginPending = createSelector(
selectLoginState,
fromLogin.getPending
);
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/root/components/admin-sidebar/admin-sidebar.component.ts
|
<filename>src/app/admin/root/components/admin-sidebar/admin-sidebar.component.ts
import { Component } from '@angular/core';
@Component({
selector: 'admin-sidebar',
templateUrl: './admin-sidebar.component.html',
styleUrls: ['./admin-sidebar.component.scss']
})
export class AdminSidebarComponent {
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/skills/containers/skill/skill.component.ts
|
import { Component, OnInit, Input } from '@angular/core';
import { Router, ActivatedRoute } from '@angular/router';
// Rxjs
import { Observable } from 'rxjs';
// ngRx
import { Store, select } from '@ngrx/store';
// Reducers
import * as fromSkills from '../../../shared/reducers/skills/skills.reducer';
// Actions
import { SkillsActions } from '../../../shared/actions/skills';
// Shared
import { Skill } from '../../../shared/models/skills/skill.model';
@Component({
selector: 'admin-skill',
templateUrl: './skill.component.html',
styleUrls: ['skill.component.scss']
})
export class SkillComponent implements OnInit {
skill: Skill;
constructor(
private store: Store<fromSkills.SkillsState>,
private router: Router,
private route: ActivatedRoute
) {}
ngOnInit() {
this.skill = !this.route.snapshot.data.skill
? {}
: this.route.snapshot.data.skill;
}
async addSkill(event: Skill) {
this.store.dispatch(new SkillsActions.CreateSkill({ skill: event }));
}
async updateSkill(event: Skill) {
const key = this.route.snapshot.params.id;
this.store.dispatch(
new SkillsActions.UpdateSkill({ skillId: key, skillChanges: event })
);
}
async removeSkill(event: Skill) {
const key = this.route.snapshot.params.id;
this.store.dispatch(new SkillsActions.DeleteSkill({ skillId: key }));
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/website.module.ts
|
<gh_stars>0
import { NgModule } from '@angular/core';
// Routing
import { RouterModule, Routes } from '@angular/router';
// Shared
import { SharedModule } from './shared/shared.module';
export const ROUTES: Routes = [
{ path: '', loadChildren: './root/website-root.module#WebsiteRootModule' }
];
@NgModule({
imports: [
RouterModule.forChild(ROUTES),
SharedModule.forRoot()
]
})
export class WebsiteModule { }
|
giorgiofederici/giorgiofederici-frontend
|
src/app/root/root.module.ts
|
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { HttpClientModule } from '@angular/common/http';
// NgRx
import { StoreModule } from '@ngrx/store';
import { reducers, metaReducers } from './reducers';
import { StoreRouterConnectingModule } from '@ngrx/router-store';
import { StoreDevtoolsModule } from '@ngrx/store-devtools';
import { EffectsModule } from '@ngrx/effects';
// Routing
import { RouterModule, Routes } from '@angular/router';
// Env
import { environment } from '../../environments/environment';
// Root
import { AppComponent } from './containers/app/app.component';
import { NotFoundPageComponent } from './components/not-found-page/not-found-page.component';
// Auth
import { AuthModule } from '../auth/auth.module';
export const ROUTES: Routes = [
{ path: '', loadChildren: '../website/website.module#WebsiteModule' },
{ path: 'admin', loadChildren: '../admin/admin.module#AdminModule' },
{ path: '404', component: NotFoundPageComponent },
{ path: '**', redirectTo: '/404' }
];
@NgModule({
imports: [
BrowserModule,
BrowserAnimationsModule,
HttpClientModule,
// Returns all providers for an @ngrx/store based application
StoreModule.forRoot(reducers, { metaReducers }),
// @ngrx/router-store keeps router state up-to-date in the store
StoreRouterConnectingModule.forRoot(),
// Store devtools instrument the store retaining past versions of state
// and recalculating new states. This enables powerful time-travel debugging.
StoreDevtoolsModule.instrument({
name: '<NAME>',
// Disable all features in production
logOnly: environment.production
}),
// Sets up the effects class to be initialized immediately when the application starts
EffectsModule.forRoot([]),
RouterModule.forRoot(ROUTES),
AuthModule
],
declarations: [AppComponent, NotFoundPageComponent],
bootstrap: [AppComponent]
})
export class RootModule {}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/models/skills/skill.model.ts
|
export interface Skill {
_id: string;
name: string;
type: string;
modifiedAt: Date;
createdAt: Date;
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/components/list-item/list-item.component.ts
|
<filename>src/app/admin/shared/components/list-item/list-item.component.ts
import {
Component,
Input,
ChangeDetectionStrategy,
Output,
EventEmitter
} from '@angular/core';
@Component({
selector: 'admin-list-item',
changeDetection: ChangeDetectionStrategy.OnPush,
styleUrls: ['list-item.component.scss'],
template: `
<div class="list-item">
<a [routerLink]="getRoute(item)">
<p class="list-item__name">{{ item.name }} [{{ item.type }}]</p>
</a>
<div class="list-item__delete" *ngIf="toggled">
<p>Delete item?</p>
<button class="confirm" type="button" (click)="removeItem()">
Yes
</button>
<button class="cancel" type="button" (click)="toggle()">No</button>
</div>
<button class="trash" type="button" (click)="toggle()">
<img src="assets/images/remove.svg" />
</button>
</div>
`
})
export class ListItemComponent {
toggled = false;
@Input() item: any;
@Output() remove: EventEmitter<any> = new EventEmitter<any>();
constructor() {}
toggle() {
this.toggled = !this.toggled;
}
removeItem() {
this.remove.emit(this.item);
}
getRoute(item: any) {
return [`../`, item._id];
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/actions/user.actions.ts
|
// NgRx
import { Action } from '@ngrx/store';
// Auth
import { User } from '../models/user.model';
export enum UserActionTypes {
GetUser = '[User] Get User',
Authenticated = '[User] Authenticated',
NotAuthenticated = '[User] Not Authenticated',
AuthenticationError = '[User] Authentication Error',
IsLoggedIn = '[User] Is Logged In'
}
export class GetUser implements Action {
readonly type = UserActionTypes.GetUser;
constructor(public payload?: any) {}
}
export class Authenticated implements Action {
readonly type = UserActionTypes.Authenticated;
constructor(public payload: { user: User }) {}
}
export class NotAuthenticated implements Action {
readonly type = UserActionTypes.NotAuthenticated;
constructor(public payload?: any) {}
}
export class AuthenticationError implements Action {
readonly type = UserActionTypes.AuthenticationError;
constructor(public payload?: any) {}
}
export class IsLoggedIn implements Action {
readonly type = UserActionTypes.IsLoggedIn;
constructor(public payload?: any) {}
}
export type UserActionsUnion =
| GetUser
| Authenticated
| NotAuthenticated
| AuthenticationError
| IsLoggedIn;
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/actions/index.ts
|
<reponame>giorgiofederici/giorgiofederici-frontend<gh_stars>0
import * as LoginActions from './login.actions';
import * as LogoutActions from './logout.actions';
import * as UserActions from './user.actions';
export { LoginActions, LogoutActions, UserActions };
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/skills/components/skill-form/skill-form.component.ts
|
import {
Component,
OnChanges,
SimpleChanges,
Input,
Output,
EventEmitter,
ChangeDetectionStrategy
} from '@angular/core';
import { FormBuilder, Validators } from '@angular/forms';
// Shared
import { Skill } from '../../../shared/models/skills/skill.model';
@Component({
selector: 'admin-skill-form',
changeDetection: ChangeDetectionStrategy.OnPush,
templateUrl: './skill-form.component.html',
styleUrls: ['skill-form.component.scss']
})
export class SkillFormComponent implements OnChanges {
toggled = false;
exists = false;
@Input()
skill: Skill;
@Output()
create = new EventEmitter<Skill>();
@Output()
update = new EventEmitter<Skill>();
@Output()
remove = new EventEmitter<Skill>();
form = this.fb.group({
name: ['', Validators.required],
type: ['', Validators.required]
});
constructor(private fb: FormBuilder) {}
ngOnChanges(changes: SimpleChanges) {
if (this.skill && this.skill.name) {
this.exists = true;
const value = this.skill;
this.form.patchValue(value);
}
}
get requiredName() {
return (
this.form.get('name').hasError('required') &&
this.form.get('name').touched
);
}
get requiredType() {
return (
this.form.get('type').hasError('required') &&
this.form.get('type').touched
);
}
createSkill() {
if (this.form.valid) {
this.create.emit(this.form.value);
}
}
updateSkill() {
if (this.form.valid) {
this.update.emit(this.form.value);
}
}
removeSkill() {
this.remove.emit(this.form.value);
}
toggle() {
this.toggled = !this.toggled;
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/website/root/containers/website-root/website-root.component.ts
|
import { Component } from '@angular/core';
@Component({
selector: 'website-root',
templateUrl: './website-root.component.html',
styleUrls: ['./website-root.component.scss']
})
export class WebsiteRootComponent { }
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/skills/skills.module.ts
|
<gh_stars>0
import { NgModule, ModuleWithProviders } from '@angular/core';
import { CommonModule } from '@angular/common';
import { ReactiveFormsModule } from '@angular/forms';
import { RouterModule, Routes } from '@angular/router';
// Font Awesome
import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
import { library } from '@fortawesome/fontawesome-svg-core';
import { faStar } from '@fortawesome/free-regular-svg-icons';
// Components
import { SkillsComponent } from './containers/skills/skills.component';
import { SkillComponent } from './containers/skill/skill.component';
import { SkillFormComponent } from './components/skill-form/skill-form.component';
// Shared
import { SharedModule } from '../shared/shared.module';
import { SkillResolver } from '../shared/resolvers/skills/skill.resolver';
export const ROUTES: Routes = [
{ path: '', component: SkillsComponent },
{ path: 'new', component: SkillComponent },
{
path: ':id',
resolve: {
skill: SkillResolver
},
component: SkillComponent
}
];
@NgModule({
imports: [
CommonModule,
ReactiveFormsModule,
RouterModule.forChild(ROUTES),
FontAwesomeModule,
SharedModule.forRoot()
],
declarations: [SkillsComponent, SkillComponent, SkillFormComponent],
providers: []
})
export class SkillsModule {
constructor() {
library.add(faStar);
}
}
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/actions/skills/index.ts
|
<filename>src/app/admin/shared/actions/skills/index.ts
import * as SkillsActions from './skills.actions';
export { SkillsActions };
|
giorgiofederici/giorgiofederici-frontend
|
src/app/auth/shared/actions/login.actions.ts
|
// ngRx
import { Action } from '@ngrx/store';
// Auth shared
import { User } from '../models/user.model';
export enum LoginActionTypes {
Login = '[Login] Login',
LoginSuccess = '[Login] Login Success',
LoginFailure = '[Login] Login Failure',
LoginRedirect = '[Login] Login Redirect'
}
export class Login implements Action {
readonly type = LoginActionTypes.Login;
constructor(public payload: { user: User }) {}
}
export class LoginSuccess implements Action {
readonly type = LoginActionTypes.LoginSuccess;
constructor(public payload: { user: User }) {}
}
export class LoginFailure implements Action {
readonly type = LoginActionTypes.LoginFailure;
constructor(public payload: { error: any }) {}
}
export class LoginRedirect implements Action {
readonly type = LoginActionTypes.LoginRedirect;
}
export type LoginActionsUnion =
| Login
| LoginSuccess
| LoginFailure
| LoginRedirect;
|
giorgiofederici/giorgiofederici-frontend
|
src/app/admin/shared/actions/projects/index.ts
|
<gh_stars>0
import * as ProjectsActions from './projects.actions';
export { ProjectsActions };
|
michalsvorc/next-auth-dynamodb-adapter
|
src/DynamoDBAdapter.ts
|
<reponame>michalsvorc/next-auth-dynamodb-adapter
import {DynamoDBClient, DynamoDBClientConfig} from '@aws-sdk/client-dynamodb';
import {AppOptions, User} from 'next-auth';
import {
Adapter,
AdapterInstance,
Profile,
Session,
VerificationRequest,
} from 'next-auth/adapters';
import logger from 'next-auth/dist/lib/logger';
import {createUser} from './methods/createUser';
import {createVerificationRequest} from './methods/createVerificationRequest';
import {deleteVerificationRequest} from './methods/deleteVerificationRequest';
import {getVerificationRequest} from './methods/getVerificationRequest';
export class DynamoDBAdapterInstance
implements AdapterInstance<User, Profile, Session, VerificationRequest> {
private readonly _appOptions: AppOptions;
private readonly _client: DynamoDBClient;
private readonly _tableOptions: TableOptions;
private readonly _logger: LoggerMethod;
readonly createVerificationRequest: ReturnType<
typeof createVerificationRequest
>;
readonly getVerificationRequest: ReturnType<typeof getVerificationRequest>;
readonly createUser: ReturnType<typeof createUser>;
readonly deleteVerificationRequest: ReturnType<
typeof deleteVerificationRequest
>;
constructor({
appOptions,
clientOptions,
tableOptions,
}: {
readonly appOptions: AppOptions;
readonly clientOptions: DynamoDBClientConfig;
readonly tableOptions: TableOptions;
}) {
this._appOptions = appOptions;
this._client = new DynamoDBClient(clientOptions);
this._tableOptions = tableOptions;
const {debug} = appOptions;
this._logger = loggerFactory({debug});
const methodOptions = {
client: this._client,
logger: this._logger,
tableOptions: this._tableOptions,
};
this.createVerificationRequest = createVerificationRequest({
...methodOptions,
appOptions: this._appOptions,
});
this.getVerificationRequest = getVerificationRequest(methodOptions);
this.createUser = createUser(methodOptions);
this.deleteVerificationRequest = deleteVerificationRequest(methodOptions);
}
readonly getUser = (id: string): Promise<User | null> => {
this._logger.debug('getUser (not implemented)', [id]);
return Promise.resolve(null);
};
readonly getUserByEmail = (email: string): Promise<User | null> => {
this._logger.debug('getUserByEmail (not implemented)', [email]);
return Promise.resolve(null);
};
readonly getUserByProviderAccountId = (
providerId: string,
providerAccountId: string
): Promise<User | null> => {
this._logger.debug('getUserByProviderAccountId (not implemented)', [
providerId,
providerAccountId,
]);
return Promise.resolve(null);
};
readonly updateUser = (user: User): Promise<User> => {
this._logger.debug('updateUser (not implemented)', [user]);
return Promise.resolve(user);
};
readonly linkAccount = (
userId: string,
_providerId: string,
_providerType: string,
_providerAccountId: string,
_refreshToken: string,
_accessToken: string,
_accessTokenExpires: number
): Promise<void> => {
this._logger.debug('linkAccount (not implemented)', [userId]);
return Promise.resolve();
};
readonly createSession = (user: User): Promise<Session> => {
this._logger.debug('createSession (not implemented)', [user]);
return Promise.resolve(mockSession);
};
readonly getSession = (sessionToken: string): Promise<Session | null> => {
this._logger.debug('getSession (not implemented)', [sessionToken]);
return Promise.resolve(mockSession);
};
readonly updateSession = (
session: Session,
_force?: boolean
): Promise<Session> => {
this._logger.debug('updateSession (not implemented)', [session]);
return Promise.resolve(mockSession);
};
readonly deleteSession = (sessionToken: string): Promise<void> => {
this._logger.debug('deleteSession (not implemented)', [sessionToken]);
return Promise.resolve();
};
}
export class DynamoDBAdapter
implements Adapter<User, Profile, Session, VerificationRequest> {
private readonly _clientOptions: DynamoDBClientConfig;
private readonly _tableOptions: TableOptions;
constructor(clientOptions: DynamoDBClientConfig, tableOptions: TableOptions) {
this._clientOptions = clientOptions;
this._tableOptions = tableOptions;
}
getAdapter(
appOptions: AppOptions
): Promise<AdapterInstance<User, Profile, Session, VerificationRequest>> {
return Promise.resolve(
new DynamoDBAdapterInstance({
appOptions: appOptions,
clientOptions: this._clientOptions,
tableOptions: this._tableOptions,
})
);
}
}
export interface TableOptions {
readonly verificationRequestsTable?: string;
readonly usersTable?: string;
}
export interface LoggerMethod {
readonly error: typeof logger.error;
readonly info: typeof logger.info;
readonly debug: typeof logger.debug | (() => null);
}
export const loggerFactory = ({
debug,
}: {
readonly debug: boolean;
}): LoggerMethod => ({
error: logger.error,
info: logger.info,
debug: debug ? logger.debug : () => null,
});
export const mockSession = {
userId: 'mockUserId',
expires: new Date(),
sessionToken: 'mockSessionToken',
accessToken: 'mockAccessToken',
};
export const VERIFICATION_TOKEN_MAX_AGE = 86400;
export const ERROR_TOKEN_EXPIRED =
'Invalid token expiration date, request new verification email.';
export const ERROR_TOKEN_EXPIRED_DATE_FORMAT =
'Token expiration is not Date object';
export const ERROR_TOKEN_INVALID = 'Invalid token signature.';
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/createVerificationRequest.ts
|
<reponame>michalsvorc/next-auth-dynamodb-adapter
import {PutItemCommand} from '@aws-sdk/client-dynamodb';
import bcrypt from 'bcrypt';
import {AppOptions} from 'next-auth';
import {EmailSessionProvider, VerificationRequest} from 'next-auth/adapters';
import {VERIFICATION_TOKEN_MAX_AGE} from '../DynamoDBAdapter';
import {DynamoDBAdapterInstance} from '../DynamoDBAdapter';
export const createVerificationRequest = ({
client,
logger,
appOptions,
tableOptions,
}: {
readonly client: DynamoDBAdapterInstance['_client'];
readonly logger: DynamoDBAdapterInstance['_logger'];
readonly appOptions: DynamoDBAdapterInstance['_appOptions'];
readonly tableOptions: DynamoDBAdapterInstance['_tableOptions'];
}) => (
email: string,
url: string,
token: string,
_secret: string,
provider: EmailSessionProvider,
_options: AppOptions
): Promise<VerificationRequest> => {
const DEBUG_ID = 'createVerificationRequest';
logger.debug(DEBUG_ID, email);
const {verificationRequestsTable} = tableOptions;
if (!verificationRequestsTable) {
return Promise.reject(
new Error('verificationRequestsTable name was not provided')
);
}
const {baseUrl} = appOptions;
const {sendVerificationRequest, maxAge} = provider;
const expires = new Date(
Date.now() + (maxAge || VERIFICATION_TOKEN_MAX_AGE) * 1000
);
return new Promise((resolve, reject) =>
bcrypt
.hash(token, 10)
.then((hashedToken) =>
client.send(
new PutItemCommand({
TableName: verificationRequestsTable,
Item: {
expires: {S: expires.toISOString()},
email: {S: email},
token: {S: hashedToken},
},
})
)
)
.then((_clientResponse) =>
sendVerificationRequest({
identifier: email,
url,
token,
baseUrl,
provider,
})
)
.then((_verificationSenderResponse) =>
resolve({
identifier: email,
token,
expires,
})
)
.catch((error) => {
logger.error(DEBUG_ID, error);
reject(error);
})
);
};
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/createUser.ts
|
<reponame>michalsvorc/next-auth-dynamodb-adapter
import {PutItemCommand} from '@aws-sdk/client-dynamodb';
import {User} from 'next-auth';
import {Profile} from 'next-auth/adapters';
import {DynamoDBAdapterInstance} from '../DynamoDBAdapter';
export const createUser = ({
client,
logger,
tableOptions,
}: {
readonly client: DynamoDBAdapterInstance['_client'];
readonly logger: DynamoDBAdapterInstance['_logger'];
readonly tableOptions: DynamoDBAdapterInstance['_tableOptions'];
}) => (profile: Profile | EmailProfile): Promise<User> => {
// TODO
const DEBUG_ID = 'createUser';
logger.debug(DEBUG_ID, profile);
const {usersTable} = tableOptions;
const {email} = profile;
const emailVerified = !isEmailProfile(profile)
? null
: profile?.emailVerified;
const name = !isEmailProfile(profile)
? profile.name
: (email as string).split('@')[0];
const id = !isEmailProfile(profile) ? profile?.id : (email as string);
const image = !isEmailProfile(profile) ? profile?.image : null;
const user = {
email,
image,
name,
};
if (!usersTable) {
logger.debug(DEBUG_ID, 'userTable name was not provided');
return Promise.resolve(user);
}
return new Promise((resolve, reject) =>
client
.send(
new PutItemCommand({
TableName: usersTable,
Item: {
email: email ? {S: email} : {NULL: true},
emailVerified: emailVerified
? {S: emailVerified.toISOString()}
: {NULL: true},
id: {S: id},
image: image ? {S: image} : {NULL: true},
name: {S: name},
},
})
)
.then((clientResponse) => {
logger.debug(DEBUG_ID, JSON.stringify({clientResponse}));
return resolve(user);
})
.catch((error) => {
logger.error(DEBUG_ID, error);
reject(error);
})
);
};
export type EmailProfile = Pick<Profile, 'email'> & {
readonly emailVerified?: Date;
};
export const isEmailProfile = (
profile: Profile | EmailProfile
): profile is EmailProfile => {
return !('id' in profile) && 'email' in profile;
};
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/createUser.spec.ts
|
import {
DeleteItemCommand,
DynamoDBClient,
GetItemCommand,
PutItemCommand,
} from '@aws-sdk/client-dynamodb';
import {jest} from '@jest/globals';
import bcrypt from 'bcrypt';
import {AppOptions} from 'next-auth';
import {Profile} from 'next-auth/adapters';
// @ts-ignore declaration file
import logger from 'next-auth/dist/lib/logger';
import {mocked} from 'ts-jest/utils';
import {dynamoDBAdapterFactory} from '../../__tests__/dynamoDBAdapterFactory';
import {mockUser} from '../../__tests__/mockUser';
import {DynamoDBAdapter} from '../DynamoDBAdapter';
import {isEmailProfile} from './createUser';
jest.mock('bcrypt');
jest.mock('@aws-sdk/client-dynamodb');
jest.mock('next-auth/dist/lib/logger');
const mockProfile: Profile = {
id: '1ab2c3d4',
...mockUser,
};
const mockHashFunction = mocked(bcrypt.hash);
const mockCompareFunction = mocked(bcrypt.compareSync);
const mockDeleteItem = mocked(DeleteItemCommand);
const mockGetItem = mocked(GetItemCommand);
const mockPutItem = mocked(PutItemCommand);
beforeEach(() => {
mocked(logger.debug).mockClear();
mockHashFunction.mockClear();
mockCompareFunction.mockClear();
mockDeleteItem.mockClear();
mockGetItem.mockClear();
mockPutItem.mockClear();
});
afterEach(() => {
mocked(DynamoDBClient.prototype.send).mockRestore();
});
afterAll(() => {
mockHashFunction.mockRestore();
mockCompareFunction.mockRestore();
mockDeleteItem.mockRestore();
mockGetItem.mockRestore();
mockPutItem.mockRestore();
});
describe('createUser', () => {
const createUserFactory = (
profile:
| Profile
| {readonly emailVerified?: Date; readonly email: string} = mockProfile
) =>
dynamoDBAdapterFactory().then((adapter) =>
adapter.createUser(profile as Profile)
);
it('should type guard EmailProfile type', () => {
const {email} = mockProfile;
expect(isEmailProfile(mockProfile)).toBe(false);
expect(isEmailProfile({email})).toBe(true);
});
it('should resolve and stop execution when usersTable name was not provided', async () => {
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const adapter = await new DynamoDBAdapter(
{region: 'us-east-1'},
{usersTable: undefined}
).getAdapter({debug: false} as AppOptions);
const result = await adapter.createUser(mockProfile);
expect(mockPutItem).not.toBeCalled();
expect(result).toStrictEqual(mockUser);
});
it('should resolve with a User for passwordless email sign in', async () => {
const {email} = mockProfile;
const emailVerified = new Date();
const name = email?.split('@')[0];
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const result = await createUserFactory({
email: email as string,
emailVerified,
});
expect(mockPutItem).toBeCalledTimes(1);
expect(mockPutItem).toBeCalledWith({
Item: {
email: {S: email},
emailVerified: {S: emailVerified.toISOString()},
id: {S: email},
image: {NULL: true},
name: {S: name},
},
TableName: 'usersTable',
});
expect(result).toStrictEqual({
email,
image: null,
name,
});
});
it('should resolve with a User for normal sign in', async () => {
const {email, id, image, name} = mockProfile;
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const result = await createUserFactory();
expect(mockPutItem).toBeCalledTimes(1);
expect(mockPutItem).toBeCalledWith({
Item: {
email: {S: email},
emailVerified: {NULL: true},
id: {S: id},
image: {S: image},
name: {S: name},
},
TableName: 'usersTable',
});
expect(result).toStrictEqual(mockUser);
});
it('should call put item with NULL values for not provided user fields', async () => {
const {id, name} = mockProfile;
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const result = await createUserFactory({
id,
name,
email: null,
});
expect(mockPutItem).toBeCalledTimes(1);
expect(mockPutItem).toBeCalledWith({
Item: {
email: {NULL: true},
emailVerified: {NULL: true},
id: {S: id},
image: {NULL: true},
name: {S: name},
},
TableName: 'usersTable',
});
expect(result).toStrictEqual({
email: null,
image: undefined,
name,
});
});
it('should be able to catch an Error and reject with it', async () => {
const ERROR_MESSAGE = 'mock error message';
mocked(DynamoDBClient.prototype.send).mockRejectedValue(
// @ts-ignore
new Error(ERROR_MESSAGE)
);
const promise = createUserFactory();
await expect(promise).rejects.toThrowError(ERROR_MESSAGE);
});
});
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/getVerificationRequest.ts
|
<reponame>michalsvorc/next-auth-dynamodb-adapter<filename>src/methods/getVerificationRequest.ts
import {GetItemCommand} from '@aws-sdk/client-dynamodb';
import bcrypt from 'bcrypt';
import {VerificationRequest} from 'next-auth/adapters';
import {SessionProvider} from 'next-auth/client';
import {
DynamoDBAdapterInstance,
ERROR_TOKEN_EXPIRED,
ERROR_TOKEN_EXPIRED_DATE_FORMAT,
ERROR_TOKEN_INVALID,
} from '../DynamoDBAdapter';
export const getVerificationRequest = ({
client,
logger,
tableOptions,
}: {
readonly client: DynamoDBAdapterInstance['_client'];
readonly logger: DynamoDBAdapterInstance['_logger'];
readonly tableOptions: DynamoDBAdapterInstance['_tableOptions'];
}) => (
email: string,
verificationToken: string,
_secret: string,
_provider: SessionProvider
): Promise<VerificationRequest | null> => {
const DEBUG_ID = 'getVerificationRequest';
logger.debug(DEBUG_ID, email, verificationToken);
const {verificationRequestsTable} = tableOptions;
if (!verificationRequestsTable) {
return Promise.reject(
new Error('verificationRequestsTable name was not provided')
);
}
const dateNow = new Date();
const ItemCommandInput = {
TableName: verificationRequestsTable,
Key: {
email: {S: email},
},
};
return new Promise((resolve, reject) =>
client
.send(new GetItemCommand(ItemCommandInput))
.then((clientResponse) => {
const expiresString = clientResponse?.Item?.expires?.S;
const token = clientResponse?.Item?.token?.S;
if (!expiresString || !token) {
logger.debug(
DEBUG_ID,
'Unable to retrieve required values from the database.'
);
return resolve(null);
}
if (Number.isNaN(Date.parse(expiresString))) {
return reject(new Error(ERROR_TOKEN_EXPIRED_DATE_FORMAT));
}
const expiresDate = new Date(expiresString);
if (expiresDate < dateNow) {
return reject(new Error(ERROR_TOKEN_EXPIRED));
}
if (!bcrypt.compareSync(verificationToken, token)) {
return reject(new Error(ERROR_TOKEN_INVALID));
}
return resolve({
identifier: email,
token,
expires: expiresDate,
});
})
.catch((error) => {
logger.error(DEBUG_ID, error);
reject(error);
})
);
};
|
michalsvorc/next-auth-dynamodb-adapter
|
src/DynamoDBAdapter.spec.ts
|
import {jest} from '@jest/globals';
import {Profile} from 'next-auth/adapters';
import {dynamoDBAdapterFactory} from '../__tests__/dynamoDBAdapterFactory';
import {mockUser} from '../__tests__/mockUser';
import {loggerFactory, mockSession} from './DynamoDBAdapter';
jest.mock('bcrypt');
jest.mock('@aws-sdk/client-dynamodb');
jest.mock('next-auth/dist/lib/logger');
const mockProfile: Profile = {
id: '1ab2c3d4',
...mockUser,
};
describe('logger', () => {
it('should output debug logs when debug option is true', async () => {
const logger = loggerFactory({debug: true});
expect(logger.debug('test')).toBeUndefined();
});
it('should output null when debug option is false', async () => {
const logger = loggerFactory({debug: false});
expect(logger.debug('test')).toBeNull();
});
});
describe('getUser (not implemented)', () => {
it('should resolve with a User or null', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.getUser(mockProfile.id);
expect(result).toBeNull();
});
});
describe('getUserByEmail (not implemented)', () => {
it('should resolve with a User or null', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.getUserByEmail(mockUser.email);
expect(result).toBeNull();
});
});
describe('getUserByProviderAccountId (not implemented)', () => {
const PROVIDER_ID = 'mockProviderId';
const PROVIDER_ACCOUNT_ID = 'mockProviderAccountId';
it('should resolve with a User or null', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.getUserByProviderAccountId(
PROVIDER_ID,
PROVIDER_ACCOUNT_ID
);
expect(result).toBeNull();
});
});
describe('updateUser (not implemented)', () => {
it('should resolve with a User', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.updateUser(mockUser);
expect(result).toStrictEqual(mockUser);
});
});
describe('linkAccount (not implemented)', () => {
const ACCESS_TOKEN = 'mockAccessToken';
const ACCESS_TOKEN_EXPIRES = 60;
const PROVIDER_ACCOUNT_ID = 'mockProviderAccountId';
const PROVIDER_ID = 'mockProviderId';
const PROVIDER_TYPE = 'mockProviderType';
const REFRESH_TOKEN = '<PASSWORD>';
it('should resolve with void', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.linkAccount(
mockProfile.id,
PROVIDER_ID,
PROVIDER_TYPE,
PROVIDER_ACCOUNT_ID,
REFRESH_TOKEN,
ACCESS_TOKEN,
ACCESS_TOKEN_EXPIRES
);
expect(result).toBeUndefined();
});
});
describe('createSession (not implemented)', () => {
it('should resolve with a Session', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.createSession(mockUser);
expect(result).toBe(mockSession);
});
});
describe('getSession (not implemented)', () => {
const SESSION_TOKEN = 'mockSessionToken';
it('should resolve with a Session', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.getSession(SESSION_TOKEN);
expect(result).toBe(mockSession);
});
});
describe('updateSession (not implemented)', () => {
const FORCE_FLAG = false;
it('should resolve with a Session', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.updateSession(mockSession, FORCE_FLAG);
expect(result).toBe(mockSession);
});
});
describe('deleteSession (not implemented)', () => {
const SESSION_TOKEN = 'mockSessionToken';
it('should resolve with void', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.deleteSession(SESSION_TOKEN);
expect(result).toBeUndefined();
});
});
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/deleteVerificationRequest.ts
|
import {DeleteItemCommand} from '@aws-sdk/client-dynamodb';
import {SessionProvider} from 'next-auth/client';
import {DynamoDBAdapterInstance} from '../DynamoDBAdapter';
export const deleteVerificationRequest = ({
client,
logger,
tableOptions,
}: {
readonly client: DynamoDBAdapterInstance['_client'];
readonly logger: DynamoDBAdapterInstance['_logger'];
readonly tableOptions: DynamoDBAdapterInstance['_tableOptions'];
}) => (
email: string,
verificationToken: string,
_secret: string,
_provider: SessionProvider
): Promise<void> => {
const DEBUG_ID = 'deleteVerification';
logger.debug(DEBUG_ID, email, verificationToken);
const {verificationRequestsTable} = tableOptions;
if (!verificationRequestsTable) {
return Promise.reject(
new Error('verificationRequestsTable name was not provided')
);
}
const ItemCommandInput = {
TableName: verificationRequestsTable,
Key: {
email: {S: email},
},
};
return new Promise((resolve, reject) =>
client
.send(new DeleteItemCommand(ItemCommandInput))
.then((_clientResponse) => resolve())
.catch((error) => {
logger.error(DEBUG_ID, error);
reject(error);
})
);
};
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/getVerificationRequest.spec.ts
|
import {DynamoDBClient, GetItemCommand} from '@aws-sdk/client-dynamodb';
import {jest} from '@jest/globals';
import bcrypt from 'bcrypt';
import {AppOptions} from 'next-auth';
import {EmailSessionProvider} from 'next-auth/adapters';
// @ts-ignore declaration file
import logger from 'next-auth/dist/lib/logger';
import {mocked} from 'ts-jest/utils';
import {dynamoDBAdapterFactory} from '../../__tests__/dynamoDBAdapterFactory';
import {mockUser} from '../../__tests__/mockUser';
import {
DynamoDBAdapter,
ERROR_TOKEN_EXPIRED,
ERROR_TOKEN_EXPIRED_DATE_FORMAT,
ERROR_TOKEN_INVALID,
} from '../DynamoDBAdapter';
jest.mock('bcrypt');
jest.mock('@aws-sdk/client-dynamodb');
jest.mock('next-auth/dist/lib/logger');
const mockHashFunction = mocked(bcrypt.hash);
const mockCompareFunction = mocked(bcrypt.compareSync);
const mockGetItem = mocked(GetItemCommand);
beforeEach(() => {
mocked(logger.debug).mockClear();
mockHashFunction.mockClear();
mockCompareFunction.mockClear();
mockGetItem.mockClear();
});
afterEach(() => {
mocked(DynamoDBClient.prototype.send).mockRestore();
});
afterAll(() => {
mockHashFunction.mockRestore();
mockCompareFunction.mockRestore();
mockGetItem.mockRestore();
});
describe('getVerificationRequest', () => {
const TOKEN = 'mockToken';
const VERIFICATION_TOKEN = '<PASSWORD>Token';
const {email} = mockUser;
const sendVerificationRequest = jest.fn(() => Promise.resolve());
beforeEach(() => {
mockCompareFunction.mockReturnValue(true);
sendVerificationRequest.mockClear();
});
const getVerificationRequestFactory = () => {
return dynamoDBAdapterFactory().then((adapter) => {
return adapter.getVerificationRequest?.(
email,
VERIFICATION_TOKEN,
'secret',
({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider
);
});
};
it('should reject with an Error when verificationRequestsTable name was not provided', async () => {
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const adapter = await new DynamoDBAdapter(
{region: 'us-east-1'},
{verificationRequestsTable: undefined}
).getAdapter({debug: false} as AppOptions);
const promise = adapter.getVerificationRequest?.(
email,
VERIFICATION_TOKEN,
'secret',
({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider
);
// @ts-ignore possibly undefined
await promise.catch((_error) => null);
expect.hasAssertions();
expect(mockGetItem).not.toBeCalled();
await expect(promise).rejects.toThrowError();
});
it('should resolve with null when retrieving token value from DB failed', async () => {
const Item = {
expires: {S: new Date().toISOString()},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
const result = await getVerificationRequestFactory();
expect(mockGetItem).toBeCalledTimes(1);
expect(result).toBeNull();
});
it('should resolve with null when retrieving expires value from DB failed', async () => {
const Item = {
token: {S: TOKEN},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
const result = await getVerificationRequestFactory();
expect(mockGetItem).toBeCalledTimes(1);
expect(result).toBeNull();
});
it('should reject with an Error and delete DB record when expires value is past current date', async () => {
const Item = {
expires: {S: new Date(Date.now() - 60).toISOString()},
token: {S: TOKEN},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
const promise = getVerificationRequestFactory();
await promise.catch((_error) => null);
expect(mockGetItem).toBeCalledTimes(1);
await expect(promise).rejects.toThrowError(ERROR_TOKEN_EXPIRED);
});
it('should reject with an Error and delete DB record when expires value can not be parsed as a Date', async () => {
const Item = {
expires: {S: 'not a date'},
token: {S: TOKEN},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
const promise = getVerificationRequestFactory();
await promise.catch((_error) => null);
expect(mockGetItem).toBeCalledTimes(1);
await expect(promise).rejects.toThrowError(ERROR_TOKEN_EXPIRED_DATE_FORMAT);
});
it('should reject with an Error and delete DB record when token verification failed', async () => {
const Item = {
expires: {S: new Date(Date.now() + 5000).toISOString()},
token: {S: TOKEN},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
mocked(mockCompareFunction).mockReturnValue(false);
const promise = getVerificationRequestFactory();
await promise.catch((_error) => null);
expect(mockCompareFunction).toBeCalledTimes(1);
expect(mockGetItem).toBeCalledTimes(1);
await expect(promise).rejects.toThrowError(ERROR_TOKEN_INVALID);
});
it('should resolve with a VerificationRequest', async () => {
const tokenExpiresString = new Date(Date.now() + 5000).toISOString();
const Item = {
expires: {S: tokenExpiresString},
token: {S: TOKEN},
};
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({Item});
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.getVerificationRequest?.(
email,
VERIFICATION_TOKEN,
'secret',
({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider
);
expect(mockGetItem).toBeCalledTimes(1);
expect(result).toStrictEqual({
expires: new Date(tokenExpiresString),
identifier: email,
token: TOKEN,
});
});
it('should be able to catch an Error and reject with it', async () => {
const ERROR_MESSAGE = 'mock error message';
mocked(DynamoDBClient.prototype.send).mockImplementationOnce(
jest.fn(() => Promise.reject(new Error(ERROR_MESSAGE)))
);
const promise = getVerificationRequestFactory();
await expect(promise).rejects.toThrowError(ERROR_MESSAGE);
});
});
|
michalsvorc/next-auth-dynamodb-adapter
|
__tests__/dynamoDBAdapterFactory.ts
|
import {AppOptions, User} from 'next-auth';
import {
AdapterInstance,
Profile,
Session,
VerificationRequest,
} from 'next-auth/adapters';
import {DynamoDBAdapter} from '../src/DynamoDBAdapter';
export const dynamoDBAdapterFactory = (
{debug} = {debug: false}
): Promise<AdapterInstance<User, Profile, Session, VerificationRequest>> =>
new DynamoDBAdapter(
{region: 'us-east-1'},
{
usersTable: 'usersTable',
verificationRequestsTable: 'verificationRequests',
}
).getAdapter({debug} as AppOptions);
|
michalsvorc/next-auth-dynamodb-adapter
|
__tests__/mockUser.ts
|
<filename>__tests__/mockUser.ts
export const mockUser = {
name: 'FirstName LastName',
email: '<EMAIL>',
image: 'https://mockdomain.com/first_last.png',
};
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/deleteVerificationRequest.spec.ts
|
import {DeleteItemCommand, DynamoDBClient} from '@aws-sdk/client-dynamodb';
import {jest} from '@jest/globals';
import {AppOptions} from 'next-auth';
import {EmailSessionProvider} from 'next-auth/adapters';
// @ts-ignore declaration file
import logger from 'next-auth/dist/lib/logger';
import {mocked} from 'ts-jest/utils';
import {dynamoDBAdapterFactory} from '../../__tests__/dynamoDBAdapterFactory';
import {mockUser} from '../../__tests__/mockUser';
import {DynamoDBAdapter} from '../DynamoDBAdapter';
jest.mock('bcrypt');
jest.mock('@aws-sdk/client-dynamodb');
jest.mock('next-auth/dist/lib/logger');
const mockDeleteItem = mocked(DeleteItemCommand);
beforeEach(() => {
mocked(logger.debug).mockClear();
mockDeleteItem.mockClear();
});
afterEach(() => {
mocked(DynamoDBClient.prototype.send).mockRestore();
});
afterAll(() => {
mockDeleteItem.mockRestore();
});
const VERIFICATION_TOKEN = '<PASSWORD>';
const {email} = mockUser;
const sendVerificationRequest = jest.fn(() => Promise.resolve());
mockDeleteItem.mockImplementation(jest.fn());
const deleteVerificationRequestFactory = () => {
return dynamoDBAdapterFactory().then((adapter) =>
adapter.deleteVerificationRequest?.(email, VERIFICATION_TOKEN, 'secret', ({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider)
);
};
describe('deleteVerificationRequest', () => {
it('should reject with an Error when verificationRequestsTable name was not provided', async () => {
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const adapter = await new DynamoDBAdapter(
{region: 'us-east-1'},
{verificationRequestsTable: undefined}
).getAdapter({debug: false} as AppOptions);
const promise = adapter.deleteVerificationRequest?.(
email,
VERIFICATION_TOKEN,
'secret',
({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider
);
// @ts-ignore possibly undefined
await promise.catch((_error) => null);
expect.hasAssertions();
expect(mockDeleteItem).not.toBeCalled();
await expect(promise).rejects.toThrowError();
});
it('should resolve with void', async () => {
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.deleteVerificationRequest?.(
email,
VERIFICATION_TOKEN,
'secret',
({
sendVerificationRequest,
maxAge: 60,
} as unknown) as EmailSessionProvider
);
expect(mockDeleteItem).toBeCalledTimes(1);
expect(result).toBeUndefined();
});
it('should be able to catch an Error and reject with it', async () => {
const ERROR_MESSAGE = 'mock error message';
mocked(DynamoDBClient.prototype.send).mockImplementationOnce(
jest.fn(() => Promise.reject(new Error(ERROR_MESSAGE)))
);
const promise = deleteVerificationRequestFactory();
await expect(promise).rejects.toThrowError(ERROR_MESSAGE);
});
});
|
michalsvorc/next-auth-dynamodb-adapter
|
src/logger.d.ts
|
declare module 'next-auth/dist/lib/logger';
|
michalsvorc/next-auth-dynamodb-adapter
|
src/methods/createVerificationRequest.spec.ts
|
import {DynamoDBClient, PutItemCommand} from '@aws-sdk/client-dynamodb';
import {jest} from '@jest/globals';
import bcrypt from 'bcrypt';
import {AppOptions} from 'next-auth';
import {EmailSessionProvider} from 'next-auth/adapters';
// @ts-ignore declaration file
import logger from 'next-auth/dist/lib/logger';
import {mocked} from 'ts-jest/utils';
import {dynamoDBAdapterFactory} from '../../__tests__/dynamoDBAdapterFactory';
import {mockUser} from '../../__tests__/mockUser';
import {DynamoDBAdapter, VERIFICATION_TOKEN_MAX_AGE} from '../DynamoDBAdapter';
jest.mock('bcrypt');
jest.mock('@aws-sdk/client-dynamodb');
jest.mock('next-auth/dist/lib/logger');
const mockHashFunction = mocked(bcrypt.hash);
const mockCompareFunction = mocked(bcrypt.compareSync);
const mockPutItem = mocked(PutItemCommand);
beforeEach(() => {
mocked(logger.debug).mockClear();
mockHashFunction.mockClear();
mockCompareFunction.mockClear();
mockPutItem.mockClear();
});
afterEach(() => {
mocked(DynamoDBClient.prototype.send).mockRestore();
});
afterAll(() => {
mockHashFunction.mockRestore();
mockCompareFunction.mockRestore();
mockPutItem.mockRestore();
});
describe('createVerificationRequest', () => {
const MAX_AGE = 60;
const SECRET = 'mockSecret';
const TOKEN = 'mockToken';
const URL = 'https://mock.com';
const {email} = mockUser;
const sendVerificationRequest = jest.fn(() => Promise.resolve());
const createVerificationRequestFactory = () => {
return dynamoDBAdapterFactory().then((adapter) => {
return adapter.createVerificationRequest?.(
email,
URL,
TOKEN,
SECRET,
({
sendVerificationRequest,
maxAge: MAX_AGE,
} as unknown) as EmailSessionProvider,
{} as AppOptions
);
});
};
mockHashFunction.mockResolvedValue('mockHashedToken');
mockPutItem.mockImplementation(jest.fn());
beforeEach(() => {
sendVerificationRequest.mockClear();
});
afterAll(() => {
sendVerificationRequest.mockRestore();
});
it('should reject with an Error when verificationRequestsTable name was not provided', async () => {
// @ts-ignore not assignable to type 'never'
mocked(DynamoDBClient.prototype.send).mockResolvedValue({});
const adapter = await new DynamoDBAdapter(
{region: 'us-east-1'},
{verificationRequestsTable: undefined}
).getAdapter({debug: false} as AppOptions);
const promise = adapter.createVerificationRequest?.(
email,
URL,
TOKEN,
SECRET,
({
sendVerificationRequest,
maxAge: MAX_AGE,
} as unknown) as EmailSessionProvider,
{} as AppOptions
);
// @ts-ignore possibly undefined
await promise.catch((_error) => null);
expect.hasAssertions();
expect(mockPutItem).not.toBeCalled();
await expect(promise).rejects.toThrowError();
});
it('should call hashing function on the token', async () => {
const SALT_ROUNDS = 10;
await createVerificationRequestFactory();
expect.hasAssertions();
expect(mockHashFunction).toBeCalledWith(TOKEN, SALT_ROUNDS);
expect(mockHashFunction).toBeCalledTimes(1);
});
it('should call client put item method', async () => {
await createVerificationRequestFactory();
expect.hasAssertions();
expect(mockPutItem).toBeCalledTimes(1);
expect(mockPutItem).toBeCalledWith(
expect.objectContaining({
TableName: 'verificationRequests',
Item: {
expires: {S: expect.any(String)},
email: {S: email},
token: {S: expect.any(String)},
},
})
);
});
it('should call passed sendVerificationRequest callback', async () => {
await createVerificationRequestFactory();
expect(sendVerificationRequest).toBeCalledTimes(1);
expect(sendVerificationRequest).toBeCalledWith(
expect.objectContaining({
identifier: email,
url: URL,
token: TOKEN,
})
);
});
describe('token validity expiration', () => {
beforeAll(() => {
jest.useFakeTimers('modern');
jest.setSystemTime(new Date('2000-12-30T00:12:00.000Z').getTime());
});
afterAll(() => {
jest.useRealTimers();
});
it('should calculate token expiration Date from passed argument', async () => {
const result = await createVerificationRequestFactory();
expect(result?.expires).toStrictEqual(
new Date(Date.now() + MAX_AGE * 1000)
);
});
it('should calculate token expiration Date from default argument value', async () => {
const adapter = await dynamoDBAdapterFactory();
const result = await adapter.createVerificationRequest?.(
email,
URL,
TOKEN,
SECRET,
({
sendVerificationRequest,
} as unknown) as EmailSessionProvider,
{} as AppOptions
);
expect(result?.expires).toStrictEqual(
new Date(Date.now() + VERIFICATION_TOKEN_MAX_AGE * 1000)
);
});
});
it('should resolve with a VerificationRequest', async () => {
const promise = createVerificationRequestFactory();
await expect(promise).resolves.toMatchObject(
expect.objectContaining({
identifier: email,
token: TOKEN,
expires: expect.any(Date),
})
);
});
it('should be able to catch an Error and reject with it', async () => {
const ERROR_MESSAGE = 'mock error message';
mocked(mockHashFunction).mockRejectedValue(new Error(ERROR_MESSAGE));
const promise = createVerificationRequestFactory();
await expect(promise).rejects.toThrowError(ERROR_MESSAGE);
});
});
|
yuanyu90221/task-management-system
|
src/auth/auth.service.spec.ts
|
<reponame>yuanyu90221/task-management-system<gh_stars>1-10
import { NotFoundException, UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Test } from '@nestjs/testing';
import { AuthService } from './auth.service';
import { UsersRepository } from './users.repository';
const mockUsersRepository = () => ({
createUser: jest.fn(),
findOne: jest.fn(),
});
const mockJwtService = () => ({
sign: jest.fn(),
});
describe('AuthService', () => {
let authService: AuthService;
let usersRepository;
let jwtService;
beforeEach(async () => {
const module = await Test.createTestingModule({
providers: [
AuthService,
{ provide: UsersRepository, useFactory: mockUsersRepository },
{ provide: JwtService, useFactory: mockJwtService },
],
}).compile();
authService = module.get<AuthService>(AuthService);
usersRepository = module.get<UsersRepository>(UsersRepository);
jwtService = module.get<JwtService>(JwtService);
});
describe('signUp', () => {
const mockAuthCredentialDto = {
username: 'mockUser',
password: '<PASSWORD>',
};
it('calls UsersRepository.createUser once', async () => {
await authService.signUp(mockAuthCredentialDto);
expect(usersRepository.createUser).toHaveBeenCalled();
});
});
describe('signIn', () => {
const mockUser = {
username: 'user1',
password: '<PASSWORD>',
};
it('calls UsersRepository.findOne and return accessToken', async () => {
const mockResolvedUser = {
username: 'user1',
password:
<PASSWORD>',
};
const mockSignResult = {
accessToken: 'signResult',
};
usersRepository.findOne.mockResolvedValue(mockResolvedUser);
jwtService.sign.mockResolvedValue(mockSignResult.accessToken);
const result = await authService.signIn(mockUser);
expect(result).toEqual(mockSignResult);
});
it('calls UsersRepository.findOne and handle an error which not found user', async () => {
usersRepository.findOne.mockResolvedValue(null);
try {
await expect(authService.signIn(mockUser)).rejects.toThrow(
UnauthorizedException,
);
} catch (error) {
throw error;
}
});
it('calls UsersRepository.findOne and handle an error which password not macth', async () => {
const mockResolvedUser = {
username: 'user1',
password:
<PASSWORD>',
};
usersRepository.findOne.mockResolvedValue(mockResolvedUser);
try {
await expect(authService.signIn(mockUser)).rejects.toThrow(
UnauthorizedException,
);
} catch (error) {
throw error;
}
});
});
});
|
yuanyu90221/task-management-system
|
src/tasks/dto/delete-task.dto.ts
|
import { IsNotEmpty, IsUUID } from 'class-validator';
export class DeleteTaskDto {
@IsUUID('4')
@IsNotEmpty()
id: string;
}
|
rinsuki/cafy
|
src/types/boolean.ts
|
<reponame>rinsuki/cafy
import Context from '../ctx';
export const isABoolean = x => typeof x == 'boolean';
export const isNotABoolean = x => !isABoolean(x);
/**
* Boolean
*/
export default class BooleanContext extends Context<boolean> {
constructor() {
super();
this.push(v =>
isNotABoolean(v)
? new Error('must-be-a-boolean')
: true
);
}
public getType(): string {
return super.getType('boolean');
}
}
|
rinsuki/cafy
|
test/index.ts
|
/**
* Tests!
*/
import * as assert from 'assert';
import $, { Context } from '../';
it('デフォルトの値を設定できる', () => {
const def = 'strawberry pasta';
const [val = def, err] = $.str.optional.get(undefined);
assert.equal(val, def);
assert.equal(err, null);
});
it('使いまわせる', () => {
const isValidGender = $.str.or('male|female').ok;
assert.equal(isValidGender('male'), true);
assert.equal(isValidGender('female'), true);
assert.equal(isValidGender('alice'), false);
});
it('nullを与えられない', () => {
const err = $.str.test(null);
assert.notEqual(err, null);
});
it('undefinedを与えられない', () => {
const err = $.str.test(undefined);
assert.notEqual(err, null);
});
it('note', () => {
const x = $.str.note(42);
assert.equal(x.data, 42);
});
describe('Common', () => {
describe('optional', () => {
it('値を与えられる', () => {
const x = 'strawberry pasta';
const [val, err] = $.str.optional.get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('nullを与えられない', () => {
const err = $.str.optional.test(null);
assert.notEqual(err, null);
});
it('undefinedを与えられる', () => {
const err = $.str.optional.test(undefined);
assert.equal(err, null);
});
});
describe('nullable', () => {
it('値を与えられる', () => {
const x = 'strawberry pasta';
const [val, err] = $.str.nullable.get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('nullを与えられる', () => {
const err = $.str.nullable.test(null);
assert.equal(err, null);
});
it('undefinedを与えられない', () => {
const err = $.str.nullable.test(undefined);
assert.notEqual(err, null);
});
});
describe('optional + nullable', () => {
it('値を与えられる', () => {
const x = 'strawberry pasta';
const [val, err] = $.str.nullable.optional.get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('nullを与えられる', () => {
const err = $.str.nullable.optional.test(null);
assert.equal(err, null);
});
it('undefinedを与えらる', () => {
const err = $.str.nullable.optional.test(undefined);
assert.equal(err, null);
});
});
describe('# throw', () => {
it('エラーをthrowする', () => {
assert.throws(() => $.num.throw('strawberry pasta'));
});
});
describe('# get', () => {
it('GOOD', () => {
const x = 'strawberry pasta';
const [v, e] = $.str.get(x);
assert.equal(v, x);
assert.equal(e, null);
});
it('BAD', () => {
const x = 42;
const [v, e] = $.str.get(x);
assert.equal(v, x);
assert.notEqual(e, null);
});
});
describe('# pipe', () => {
it('バリデータが true を返したら合格', () => {
const err = $.str.pipe(() => true).test('strawberry pasta');
assert.equal(err, null);
});
it('バリデータが false を返したら失格', () => {
const err = $.str.pipe(() => false).test('strawberry pasta');
assert.notEqual(err, null);
});
it('バリデータが Error を返したら失格', () => {
const err = $.str.pipe(() => new Error('something')).test('strawberry pasta');
assert.notEqual(err, null);
});
it('nullのときには実行されない', () => {
const err = $.str.nullable.pipe(x => x[0] == 'a').test(null);
assert.equal(err, null);
});
it('undefinedのときには実行されない', () => {
const err = $.str.optional.pipe(x => x[0] == 'a').test(undefined);
assert.equal(err, null);
});
});
});
describe('Queries', () => {
describe('String', () => {
it('正当な値を与える', () => {
const x = 'strawberry pasta';
const [val, err] = $.str.get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('文字列以外でエラー', () => {
const x = [1, 2, 3];
const [val, err] = $.str.get(x);
assert.notEqual(err, null);
});
it('サロゲートペア', () => {
const ok = $.str.length(1).ok('😀');
assert.equal(ok, true);
});
describe('# min', () => {
it('しきい値より長くて成功', () => {
const err = $.str.min(8).test('strawberry');
assert.equal(err, null);
});
it('しきい値より短くて失敗', () => {
const err = $.str.min(8).test('pasta');
assert.notEqual(err, null);
});
});
describe('# max', () => {
it('しきい値より短くて成功', () => {
const err = $.str.max(8).test('pasta');
assert.equal(err, null);
});
it('しきい値より長くて失敗', () => {
const err = $.str.max(8).test('strawberry');
assert.notEqual(err, null);
});
});
it('# length', () => {
const validate = $.str.length(3).test;
const x = 'abc';
assert.equal(validate(x), null);
const y = 'abcd';
assert.notEqual(validate(y), null);
});
describe('# match', () => {
it('マッチして成功', () => {
const err = $.str.match(/^[a-z]+$/).test('foo');
assert.equal(err, null);
});
it('マッチせず失敗', () => {
const err = $.str.match(/^[a-z]+$/).test('foo123');
assert.notEqual(err, null);
});
});
describe('# notMatch', () => {
it('マッチして失敗', () => {
const err = $.str.notMatch(/^[a-z]+$/).test('foo');
assert.notEqual(err, null);
});
it('マッチせず成功', () => {
const err = $.str.notMatch(/^[a-z]+$/).test('foo123');
assert.equal(err, null);
});
});
describe('# or', () => {
it('合致する文字列で成功 (配列)', () => {
const err = $.str.or(['strawberry', 'pasta']).test('strawberry');
assert.equal(err, null);
});
it('合致しない文字列で失敗 (配列)', () => {
const err = $.str.or(['strawberry', 'pasta']).test('alice');
assert.notEqual(err, null);
});
it('合致する文字列で成功 (文字列)', () => {
const err = $.str.or('strawberry|pasta').test('strawberry');
assert.equal(err, null);
});
it('合致しない文字列で失敗 (文字列)', () => {
const err = $.str.or('strawberry|pasta').test('alice');
assert.notEqual(err, null);
});
});
describe('# notInclude', () => {
it('含まない文字列で成功 (配列)', () => {
const err = $.str.notInclude(['alice', 'tachibana']).test('strawberry pasta');
assert.equal(err, null);
});
it('含む文字列で失敗 (配列)', () => {
const err = $.str.notInclude(['alice', 'tachibana']).test('strawberry alice');
assert.notEqual(err, null);
});
it('含まない文字列で成功 (文字列)', () => {
const err = $.str.notInclude('alice').test('strawberry pasta');
assert.equal(err, null);
});
it('含む文字列で失敗 (文字列)', () => {
const err = $.str.notInclude('alice').test('strawberry alice');
assert.notEqual(err, null);
});
});
});
describe('Number', () => {
it('正当な値を与える', () => {
const x = 42;
const [val, err] = $.num.get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('数値以外でエラー', () => {
const x = 'strawberry pasta';
const [val, err] = $.num.get(x);
assert.notEqual(err, null);
});
describe('# int', () => {
it('整数で合格', () => {
const err = $.num.int().test(42);
assert.equal(err, null);
});
it('非整数で不合格', () => {
const err = $.num.int().test(3.14);
assert.notEqual(err, null);
});
});
describe('# min', () => {
it('しきい値より大きくて成功', () => {
const err = $.num.min(42).test(50);
assert.equal(err, null);
});
it('しきい値より小さくて失敗', () => {
const err = $.num.min(42).test(30);
assert.notEqual(err, null);
});
});
describe('# max', () => {
it('しきい値より小さくて成功', () => {
const err = $.num.max(42).test(30);
assert.equal(err, null);
});
it('しきい値より大きくて失敗', () => {
const err = $.num.max(42).test(50);
assert.notEqual(err, null);
});
});
});
describe('Array', () => {
it('正当な値を与える', () => {
const x = [1, 2, 3];
const [val, err] = $.arr().get(x);
assert.equal(val, x);
assert.equal(err, null);
});
it('配列以外でエラー', () => {
const x = 'strawberry pasta';
const [val, err] = $.arr().get(x);
assert.notEqual(err, null);
});
describe('要素の型指定', () => {
it('正当な値を与えて合格', () => {
const err = $.arr($.str).test(['a', 'b', 'c']);
assert.equal(err, null);
});
it('不正な値を与えて不合格', () => {
const err = $.arr($.str).test(['a', 1, 'c']);
assert.notEqual(err, null);
});
});
describe('入れ子', () => {
it('正しく成功する', () => {
const err = $.arr($.num.range(0, 10)).test([1, 2, 3]);
assert.equal(err, null);
});
it('正しく失敗する', () => {
const err = $.arr($.num.range(0, 10)).test([1, -1, 3]);
assert.notEqual(err, null);
});
});
describe('# unique', () => {
it('ユニークで合格', () => {
const err = $.arr().unique().test(['a', 'b', 'c']);
assert.equal(err, null);
});
it('重複した要素が有って不合格', () => {
const err = $.arr().unique().test(['a', 'b', 'c', 'b']);
assert.notEqual(err, null);
});
});
describe('# min', () => {
it('しきい値より長くて成功', () => {
const err = $.arr().min(3).test([1, 2, 3, 4]);
assert.equal(err, null);
});
it('しきい値より短くて失敗', () => {
const err = $.arr().min(3).test([1, 2]);
assert.notEqual(err, null);
});
});
describe('# max', () => {
it('しきい値より短くて成功', () => {
const err = $.arr().max(3).test([1, 2]);
assert.equal(err, null);
});
it('しきい値より長くて失敗', () => {
const err = $.arr().max(3).test([1, 2, 3, 4]);
assert.notEqual(err, null);
});
});
it('# length', () => {
const validate = $.arr().length(3).test;
const x = [1, 2, 3];
assert.equal(validate(x), null);
const y = [1, 2, 3, 4];
assert.notEqual(validate(y), null);
});
it('# item', () => {
const validate = $.arr().item(1, $.num).test;
const x = ['a', 42, 'c'];
assert.equal(validate(x), null);
const y = ['a', 'b', 'c'];
assert.notEqual(validate(y), null);
});
describe('# each', () => {
it('バリデータが true を返したら合格', () => {
const err = $.arr().each(() => true).test([1, 2, 3]);
assert.equal(err, null);
});
it('バリデータが false を返したら失格', () => {
const err = $.arr().each(() => false).test([1, 2, 3]);
assert.notEqual(err, null);
});
it('バリデータが Error を返したら失格', () => {
const err = $.arr().each(() => new Error('something')).test([1, 2, 3]);
assert.notEqual(err, null);
});
});
});
describe('Boolean', () => {
it('正当な値を与える', () => {
const x = true;
const [valx, errx] = $.bool.get(x);
assert.equal(valx, x);
assert.equal(errx, null);
const y = false;
const [valy, erry] = $.bool.get(y);
assert.equal(valy, y);
assert.equal(erry, null);
});
it('真理値以外でエラー', () => {
const x = 'strawberry pasta';
const [val, err] = $.bool.get(x);
assert.notEqual(err, null);
});
});
describe('Object', () => {
it('正当な値を与えられる', () => {
const x = { myProp: 42 };
const [val, err] = $.obj().get(x);
assert.deepEqual(val, x);
assert.equal(err, null);
});
it('オブジェクト以外でエラー', () => {
const x = 'strawberry pasta';
const err = $.obj().test(x);
assert.notEqual(err, null);
});
it('オブジェクト以外でエラー (配列)', () => {
const x = [];
const err = $.obj().test(x);
assert.notEqual(err, null);
});
it('strict', () => {
const err1 = $.obj({
x: $.num
}).strict().test({ x: 42 });
assert.equal(err1, null);
const err2 = $.obj({
x: $.num
}).strict().test({ x: 42, y: 24 });
assert.notEqual(err2, null);
const err3 = $.obj({
x: $.num,
y: $.num
}).strict().test({ x: 42, y: 24 });
assert.equal(err3, null);
const err4 = $.obj({
x: $.num
}).test({ x: 42, y: 24 });
assert.equal(err4, null);
});
it('strict (null)', () => {
const err1 = $.obj({
x: $.num
}).strict().test(null);
assert.notEqual(err1, null);
const err2 = $.obj({
x: $.num
}).strict().nullable.test(null);
assert.equal(err2, null);
});
it('strict (undefined)', () => {
const err1 = $.obj({
x: $.num
}).strict().test(undefined);
assert.notEqual(err1, null);
const err2 = $.obj({
x: $.num
}).strict().optional.test(undefined);
assert.equal(err2, null);
});
it('入れ子', () => {
const validate = $.obj({
some: $.obj({
strawberry: $.str,
alice: $.bool,
tachibana: $.obj({
bwh: $.arr($.num)
})
}),
thing: $.num
}).test;
const x = {
some: {
strawberry: 'pasta',
alice: false,
tachibana: {
bwh: [68, 52, 67]
}
},
thing: 42
};
assert.equal(validate(x), null);
const y = {
some: {
strawberry: 'pasta',
alice: false,
tachibana: {
bwh: [68, '52', 67]
}
},
thing: 42
};
assert.notEqual(validate(y), null);
});
});
describe('Or', () => {
it('OK', () => {
const ok = $.or($.str, $.num).ok(42);
assert.equal(ok, true);
});
it('NOT OK', () => {
const ok = $.or($.str, $.num).ok({});
assert.equal(ok, false);
});
it('With array', () => {
const ok = $.arr($.or($.str, $.num)).ok(['x', 42]);
assert.equal(ok, true);
});
it('Type', () => {
const type = $.or($.str, $.num).getType();
assert.equal(type, '(string | number)');
});
});
describe('use', () => {
it('OK', () => {
const ok = $.use($.num).ok(42);
assert.equal(ok, true);
});
it('NOT OK', () => {
const ok = $.use($.num).ok('foo');
assert.equal(ok, false);
});
it('optional', () => {
const base = $.num;
const ok1 = $.use(base).optional.ok(undefined);
assert.equal(ok1, true);
const ok2 = $.use(base).ok(undefined);
assert.equal(ok2, false);
});
});
});
class MyClass {
x: number;
}
class MyClassContext extends Context<MyClass> {
constructor() {
super();
this.push(v =>
v instanceof MyClass ? true : new Error('value is not an instance of MyClass')
);
}
}
it('Custom Context', () => {
const ok1 = $.type(MyClassContext).ok(new MyClass());
assert.equal(ok1, true);
const ok2 = $.type(MyClassContext).ok('abc');
assert.equal(ok2, false);
const ok3 = $.arr($.type(MyClassContext)).ok([new MyClass(), new MyClass()]);
assert.equal(ok3, true);
const ok4 = $.arr($.type(MyClassContext)).ok([new MyClass(), 42]);
assert.equal(ok4, false);
});
|
rinsuki/cafy
|
src/ctx.ts
|
import autobind from './autobind';
import Validator from './validator';
/**
* Context基底クラス
*/
abstract class Context<T = any> {
public isOptional = false;
public isNullable = false;
public data: any;
private validators: Validator<T>[] = [];
/**
* バリデーションを追加します
* @param validator バリデータ
* @param name バリデータ名
*/
@autobind
protected push(validator: Validator<T>, name?: string) {
validator.toString = name ? () => name : () => null;
this.validators.push(validator);
}
private exec(value: any): Error;
private exec(value: any, withValue: boolean): [any, Error];
@autobind
private exec(value: any, withValue?: boolean): Error | [any, Error] {
function res(val, err) {
return withValue ? [val, err] : err;
}
if (this.isOptional && (value === undefined)) return res(value, null);
if (this.isNullable && (value === null)) return res(value, null);
if (!this.isOptional && (value === undefined)) return res(null, new Error('must-be-not-undefined'));
if (!this.isNullable && (value === null)) return res(null, new Error('must-be-not-null'));
let err = null;
this.validators.some(validate => {
const result = validate(value);
if (result === false) {
err = new Error('something-happened');
return true;
} else if (result instanceof Error) {
err = result;
return true;
} else {
return false;
}
});
return res(value, err);
}
/**
* 値を検証して、バリデーションに不合格なら Error をthrowします。
*/
@autobind
public throw(value: any): void {
const [v, e] = this.exec(value, true);
if (e) {
throw e;
} else {
return v;
}
}
/**
* 値を検証して、妥当な場合は null を、そうでない場合は Error を返します。
*/
@autobind
public test(value: any): Error {
return this.exec(value);
}
/**
* 値を検証して、妥当な場合は true を、そうでない場合は false を返します
*/
@autobind
public ok(value: any): boolean {
return this.test(value) == null;
}
/**
* 値を検証して、妥当な場合は false を、そうでない場合は true を返します
*/
@autobind
public nok(value: any): boolean {
return !this.ok(value);
}
/**
* 値を検証して、値およびエラーを取得します
*/
@autobind
public get(value: any): [T, Error] {
return this.exec(value, true);
}
/**
* このインスタンスの値に対して妥当性を検証します
* バリデータが false またはエラーを返した場合エラーにします
* @param validator バリデータ
*/
@autobind
public pipe(validator: Validator<T>) {
this.push(validator, 'pipe');
return this;
}
/**
* このインスタンスに任意のデータを保存します
* @param data データ
*/
@autobind
public note(data: any) {
this.data = data;
return this;
}
/**
* undefined を許可します。
*/
get optional() {
this.isOptional = true;
return this;
}
/**
* null を許可します。
*/
get nullable() {
this.isNullable = true;
return this;
}
/**
* このcafyインスタンスを表す文字列を取得します
*/
@autobind
public toString(verbose = false) {
return this.constructor.name + ' ' + (verbose
? `(${this.validators.map(v => v.toString() || '[anonymous]').join(' > ')})`
: `(${this.validators.map(v => v.toString()).filter(n => n != null).join(' > ')})`);
}
/**
* このcafyインスタンスの型を表す文字列を取得します
*/
public getType(type = 'unknown') {
return this.isNullable && this.isOptional ? `(${type} | null)?` :
this.isNullable && !this.isOptional ? `(${type} | null)` :
!this.isNullable && this.isOptional ? `${type}?` :
type;
}
}
export default Context;
|
rinsuki/cafy
|
src/index.ts
|
/**
* cafy
*/
import AnyContext from './types/any';
import ArrayContext from './types/array';
import BooleanContext from './types/boolean';
import NumberContext from './types/number';
import ObjectContext, { Props } from './types/object';
import StringContext from './types/string';
import OrContext from './types/or';
import Context from './ctx';
import { TypeOf } from './types';
export default {
get any() { return new AnyContext() },
arr<T extends Context = Context>(ctx?: T): ArrayContext<T> { return new ArrayContext(ctx) },
array<T extends Context = Context>(ctx?: T): ArrayContext<T> { return new ArrayContext(ctx) },
get bool() { return new BooleanContext() },
get boolean() { return new BooleanContext() },
get num() { return new NumberContext() },
get number() { return new NumberContext() },
obj<T extends Props>(ctx?: T): ObjectContext<T> { return new ObjectContext(ctx) },
object<T extends Props>(ctx?: T): ObjectContext<T> { return new ObjectContext(ctx) },
or<CtxA extends Context, CtxB extends Context>(ctxA: CtxA, ctxB: CtxB): OrContext<CtxA, CtxB> { return new OrContext(ctxA, ctxB) },
get str() { return new StringContext() },
get string() { return new StringContext() },
type<T>(Ctx: { new(): T; }): T { return new Ctx() },
use<T extends Context = Context>(ctx: T): AnyContext<TypeOf<T>> {
return new AnyContext<TypeOf<T>>().pipe(ctx.test);
}
};
export {
Context,
AnyContext,
ArrayContext,
BooleanContext,
NumberContext,
ObjectContext,
StringContext,
OrContext
};
|
rinsuki/cafy
|
src/validator.ts
|
type Validator<T> = (value: T) => boolean | Error;
export default Validator;
|
rinsuki/cafy
|
src/types/number.ts
|
<gh_stars>0
import Context from '../ctx';
export const isANumber = x => Number.isFinite(x);
export const isNotANumber = x => !isANumber(x);
/**
* Number
*/
export default class NumberContext extends Context<number> {
constructor() {
super();
this.push(v =>
isNotANumber(v)
? new Error('must-be-a-number')
: true
);
}
/**
* 値が指定された範囲内にない場合エラーにします
* @param min 下限
* @param max 上限
*/
public range(min: number, max: number) {
this.min(min);
this.max(max);
return this;
}
/**
* このインスタンスの値が指定された下限より下回っている場合エラーにします
* @param threshold 下限
*/
public min(threshold: number) {
this.push(v =>
v < threshold
? new Error('invalid-range')
: true
, 'min');
return this;
}
/**
* このインスタンスの値が指定された上限より上回っている場合エラーにします
* @param threshold 上限
*/
public max(threshold: number) {
this.push(v =>
v > threshold
? new Error('invalid-range')
: true
, 'max');
return this;
}
/**
* このインスタンスの値が整数でなければエラーにします
*/
public int() {
this.push(v =>
!Number.isInteger(v)
? new Error('must-be-an-intager')
: true
, 'int');
return this;
}
public getType(): string {
return super.getType('number');
}
}
|
rinsuki/cafy
|
src/types/array.ts
|
<reponame>rinsuki/cafy
import Context from '../ctx';
import StringContext from './string';
import NumberContext from './number';
import AnyContext from './any';
import BooleanContext from './boolean';
import ObjectContext from './object';
import { TypeOf } from '.';
export const isAnArray = x => Array.isArray(x);
export const isNotAnArray = x => !isAnArray(x);
const hasDuplicates = (array: any[]) => (new Set(array)).size !== array.length;
/**
* Array
*/
export default class ArrayContext<Ctx extends Context> extends Context<TypeOf<Ctx>[]> {
private ctx: Context;
constructor(ctx?: Context) {
super();
this.ctx = ctx;
this.push(v =>
isNotAnArray(v)
? new Error('must-be-an-array')
: true
);
if (ctx) {
this.each(ctx);
}
}
/**
* 配列の値がユニークでない場合(=重複した項目がある場合)エラーにします
*/
public unique() {
this.push(v =>
hasDuplicates(v)
? new Error('must-be-unique')
: true
, 'unique');
return this;
}
/**
* 配列の長さが指定された範囲内にない場合エラーにします
* @param min 下限
* @param max 上限
*/
public range(min: number, max: number) {
this.min(min);
this.max(max);
return this;
}
/**
* 配列の長さが指定された下限より下回っている場合エラーにします
* @param threshold 下限
*/
public min(threshold: number) {
this.push(v =>
v.length < threshold
? new Error('invalid-range')
: true
, 'min');
return this;
}
/**
* 配列の長さが指定された上限より上回っている場合エラーにします
* @param threshold 上限
*/
public max(threshold: number) {
this.push(v =>
v.length > threshold
? new Error('invalid-range')
: true
, 'max');
return this;
}
/**
* 指定された数の要素を持っていなければエラーにします
* @param length 要素数
*/
public length(length: number) {
this.push(v =>
v.length !== length
? new Error('invalid-length')
: true
, 'length');
return this;
}
/**
* 指定されたインデックスの要素に対して妥当性を検証します
* バリデータが false またはエラーを返した場合エラーにします
* @param index インデックス
* @param validator バリデータ
*/
public item(index: number, validator: ((element: TypeOf<Ctx>) => boolean | Error) | Context) {
const validate = validator instanceof Context ? validator.test : validator;
this.push(v => {
const result = validate(v[index]);
if (result === false) {
return new Error('invalid-item');
} else if (result instanceof Error) {
return result;
} else {
return true;
}
}, 'item');
return this;
}
/**
* 配列の各要素に対して妥当性を検証します
* バリデータが false またはエラーを返した場合エラーにします
* @param validator バリデータ
*/
public each(validator: ((element: TypeOf<Ctx>, index: number, array: TypeOf<Ctx>[]) => boolean | Error) | Context) {
const validate = validator instanceof Context ? validator.test : validator;
this.push(v => {
let err: Error;
v.some((x, i, s) => {
const result = validate(x, i, s);
if (result === false) {
err = new Error('invalid-item');
return true;
} else if (result instanceof Error) {
err = result;
return true;
} else {
return false;
}
});
if (err) return err;
return true;
}, 'each');
return this;
}
public getType(): string {
return super.getType(this.ctx ? this.ctx.getType() + '[]' : 'array');
}
}
|
rinsuki/cafy
|
src/types/object.ts
|
<gh_stars>0
import Context from '../ctx';
import { TypeOf } from '.';
export const isAnObject = x => typeof x == 'object' && !(x instanceof Array);
export const isNotAnObject = x => !isAnObject(x);
export type Props = { [key: string]: Context };
/**
* Object
*/
export default class ObjectContext<Ps extends Props> extends Context<{ [P in keyof Ps]: TypeOf<Ps[P]> }> {
private isStrict = false;
public props: Props;
constructor(props?: Props) {
super();
this.props = props;
this.push(v =>
isNotAnObject(v)
? new Error('must-be-an-object')
: true
);
if (props) {
Object.entries(props).forEach(([k, ctx]) => {
this.push(v => ctx.test(v[k]));
});
}
this.push(v => {
if (this.isStrict) {
const actual = Object.keys(v);
const expect = Object.keys(props);
const hasNotMentionedProperty = actual.some(p => !expect.some(m => m == p));
if (hasNotMentionedProperty) return new Error('dirty-object');
}
return true;
});
}
/**
* 言及したプロパティ以外のプロパティを持つことを禁止します。
*/
public strict() {
this.isStrict = true;
return this;
}
public getType(): string {
return super.getType('object');
}
}
|
rinsuki/cafy
|
src/autobind.ts
|
export default function(target: any, key: string, descriptor: PropertyDescriptor) {
const fn = descriptor.value || descriptor.get;
return {
configurable: true,
get() {
const bound = fn.bind(this);
Object.defineProperty(this, key, {
configurable: true,
writable: true,
value: bound
});
return bound;
}
};
};
|
rinsuki/cafy
|
src/types/or.ts
|
import Context from '../ctx';
import { TypeOf } from '.';
/**
* Or
*/
export default class OrContext<CtxA extends Context, CtxB extends Context> extends Context<TypeOf<CtxA> | TypeOf<CtxB>> {
private ctxA: Context;
private ctxB: Context;
constructor(ctxA: Context, ctxB: Context) {
super();
this.ctxA = ctxA;
this.ctxB = ctxB;
this.push(v =>
ctxA.nok(v) && ctxB.nok(v) ? new Error('not match') : true
);
}
public getType(): string {
return super.getType(`(${this.ctxA.getType()} | ${this.ctxB.getType()})`);
}
}
|
rinsuki/cafy
|
src/types/string.ts
|
<gh_stars>0
import Context from '../ctx';
export const isAString = x => typeof x == 'string';
export const isNotAString = x => !isAString(x);
function stringToArray(str) {
return str.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
}
/**
* String
*/
export default class StringContext extends Context<string> {
constructor() {
super();
this.push(v =>
isNotAString(v)
? new Error('must-be-a-string')
: true
);
}
/**
* 文字数が指定された範囲内にない場合エラーにします
* @param min 下限
* @param max 上限
*/
public range(min: number, max: number) {
this.min(min);
this.max(max);
return this;
}
/**
* 文字数が指定された下限より下回っている場合エラーにします
* @param threshold 下限
*/
public min(threshold: number) {
this.push(v =>
stringToArray(v).length < threshold
? new Error('invalid-range')
: true
, 'min');
return this;
}
/**
* 文字数が指定された上限より上回っている場合エラーにします
* @param threshold 上限
*/
public max(threshold: number) {
this.push(v =>
stringToArray(v).length > threshold
? new Error('invalid-range')
: true
, 'max');
return this;
}
/**
* 指定された文字数でなければエラーにします
* @param length 文字数
*/
public length(length: number) {
this.push(v =>
stringToArray(v).length !== length
? new Error('invalid-length')
: true
, 'length');
return this;
}
/**
* このインスタンスの文字列が、与えられたパターン内の文字列のどれかと一致するか検証します
* どれとも一致しない場合エラーにします
* @param pattern 文字列の配列または|で区切られた文字列
*/
public or(pattern: string | string[]) {
if (typeof pattern == 'string') pattern = pattern.split('|');
this.push(v => {
const match = (pattern as string[]).some(x => x === v);
if (!match) return new Error('not-match-pattern');
return true;
}, 'or');
return this;
}
/**
* このインスタンスの文字列が、与えられた文字列を含んでいないか検証します
* 含んでいる場合エラーにします
* @param str 文字列または文字列の配列
*/
public notInclude(str: string | string[]) {
if (typeof str == 'string') str = [str];
this.push(v => {
const match = (str as string[]).some(x => v.indexOf(x) !== -1);
if (match) return new Error('includes-forbidden-string');
return true;
}, 'notInclude');
return this;
}
/**
* このインスタンスの文字列が、与えられた正規表現と一致するか検証します
* 一致しない場合エラーにします
* @param pattern 正規表現
*/
public match(pattern: RegExp) {
this.push(v =>
!pattern.test(v)
? new Error('not-match-pattern')
: true
, 'match');
return this;
}
/**
* このインスタンスの文字列が、与えられた正規表現と一致しないか検証します
* 一致する場合エラーにします
* @param pattern 正規表現
*/
public notMatch(pattern: RegExp) {
this.push(v =>
pattern.test(v)
? new Error('match-pattern')
: true
, 'notMatch');
return this;
}
public getType(): string {
return super.getType('string');
}
}
|
rinsuki/cafy
|
src/types/any.ts
|
<reponame>rinsuki/cafy<gh_stars>0
import Context from '../ctx';
/**
* Any
*/
export default class AnyContext<T = any> extends Context<T> {
public getType(): string {
return super.getType('any');
}
}
|
dev-rish/rishtickets-common
|
src/events/order-created-event.ts
|
import { Subjects } from "./subjects";
import { OrderStatus } from "./types/order-status";
export interface OrderCreatedEvent {
subject: Subjects.OrderCreated;
data: {
id: string;
version: number;
status: OrderStatus;
userId: string;
expiresAt: string;
ticket: {
id: string;
price: number;
};
};
}
|
dev-rish/rishtickets-common
|
src/errors/database-connection-error.ts
|
import { CustomError } from "./custom-error";
export class DatabaseConnectionError extends CustomError {
statusCode = 500;
reason = "Error connecting to database";
constructor() {
super("Error connecting to database");
// NOTE: Required when extending a built in class
Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
}
serializeError() {
return [{ message: this.reason }];
}
}
|
dev-rish/rishtickets-common
|
src/errors/request-validation-error.ts
|
import { ValidationError } from "express-validator";
import { CustomError } from "./custom-error";
export class RequestValidationError extends CustomError {
statusCode = 400;
constructor(public errors: ValidationError[]) {
super("Invalid request parameters");
// NOTE: Required when extending a built in class
Object.setPrototypeOf(this, RequestValidationError.prototype);
}
serializeError() {
return this.errors.map((e) => ({ message: e.msg, field: e.param }));
}
}
|
dev-rish/rishtickets-common
|
src/errors/unauthorized-error.ts
|
<filename>src/errors/unauthorized-error.ts
import { CustomError } from "./custom-error";
export class UnauthorizedError extends CustomError {
statusCode = 401;
constructor() {
super("Not authorized");
Object.setPrototypeOf(this, UnauthorizedError.prototype);
}
serializeError() {
return [{ message: "Not authorized" }];
}
}
|
dev-rish/rishtickets-common
|
src/events/types/order-status.ts
|
export enum OrderStatus {
/**
* 1. When the order has been created but the associated
* ticket has not been reserved
*/
Created = "created",
/**
* 1. Associated ticket is already reserved
* 2. User cancelled the order
* 3. Order expires before payment
*/
Cancelled = "cancelled",
/**
* 1. Associated ticket reserved successfully
*/
AwaitingPayment = "awaiting:payment",
/**
* 1. Associated ticket reserved and the payment done successfully
*/
Complete = "complete"
}
|
vsomasvr/ng-orderby-pipe
|
src/order-by.module.ts
|
import { NgModule } from '@angular/core';
import { OrderByPipe } from './order-by.pipe';
@NgModule({
declarations:[OrderByPipe],
exports:[OrderByPipe],
providers:[OrderByPipe]
})
export class OrderByModule { }
|
vsomasvr/ng-orderby-pipe
|
index.ts
|
<filename>index.ts
export * from './src/order-by.module'
export * from './src/order-by.pipe';
|
vsomasvr/ng-orderby-pipe
|
src/order-by.pipe.ts
|
<gh_stars>0
import { Pipe, PipeTransform } from '@angular/core';
@Pipe({ name: 'orderBy' })
export class OrderByPipe implements PipeTransform {
transform(values: any[], objectKeyWithPath: string = '', order: string = 'asc'): any {
const predicatePathValues: string[] = objectKeyWithPath.split('.');
const desc: boolean = order === 'desc';
if (!objectKeyWithPath) {
return desc ? values.sort().reverse() : values.sort();
}
return values.sort((a, b) => {
let result:any = 0;
let leftSideValue: any = a;
let rightSideValue: any = b;
predicatePathValues.forEach((predicate) => {
leftSideValue = leftSideValue[predicate];
rightSideValue = rightSideValue[predicate];
});
if (leftSideValue < rightSideValue) {
result = desc ? 1 : -1;
} else if (rightSideValue < leftSideValue) {
result = desc ? -1 : 1;
}
return result;
});
}
}
|
vsomasvr/ng-orderby-pipe
|
tests/order-by.pipe.spec.ts
|
<gh_stars>0
import {OrderByPipe} from '../src/order-by.pipe';
describe('OrderByPipe Tests', () => {
let pipe: OrderByPipe;
beforeEach(() => {
pipe = new OrderByPipe();
});
it('Should order an array of strings', () => {
const values = ['Think Pad', 'Macbook Pro', 'Galago Pro', 'XPS'];
const result = pipe.transform(values);
expect(result).toEqual(['Galago Pro', 'Macbook Pro', 'Think Pad', 'XPS']);
const result2 = pipe.transform(values, '', 'desc');
expect(result2).toEqual(['XPS', 'Think Pad', 'Macbook Pro', 'Galago Pro']);
});
it('Should order an array of objects', () => {
const values = [
{
name: 'Think Pad',
mfgYear: 2017
},
{
name: 'Macbook Pro',
mfgYear: 2016
},
{
name: '<NAME>',
mfgYear: 2020
},
{
name: 'XPS',
mfgYear: 2019
}
];
const result = pipe.transform(values, 'name');
expect(result).toEqual([
{
name: '<NAME>',
mfgYear: 2020
},
{
name: 'Macbook Pro',
mfgYear: 2016
},
{
name: 'Think Pad',
mfgYear: 2017
},
{
name: 'XPS',
mfgYear: 2019
}
]);
const result2 = pipe.transform(values, 'name' , 'desc');
expect(result2).toEqual([
{
name: 'XPS',
mfgYear: 2019
},
{
name: 'Think Pad',
mfgYear: 2017
},
{
name: 'Macbook Pro',
mfgYear: 2016
},
{
name: 'Galago Pro',
mfgYear: 2020
}
]);
});
it('Should order an array of objects with nested object', () => {
const values = [
{
name: '<NAME>',
mfgYear: 2017,
config: {
memory: 32
}
},
{
name: 'Macbook Pro',
mfgYear: 2016,
config: {
memory: 16
}
},
{
name: '<NAME>',
mfgYear: 2020,
config: {
memory: 64
}
},
{
name: 'XPS',
mfgYear: 2019,
config: {
memory: 8
}
}
];
const result = pipe.transform(values, 'config.memory');
expect(result).toEqual([
{
name: 'XPS',
mfgYear: 2019,
config: {
memory: 8
}
},
{
name: 'Macbook Pro',
mfgYear: 2016,
config: {
memory: 16
}
},
{
name: 'Think Pad',
mfgYear: 2017,
config: {
memory: 32
}
},
{
name: '<NAME>',
mfgYear: 2020,
config: {
memory: 64
}
}
]);
const result2 = pipe.transform(values, 'config.memory' , 'desc');
expect(result2).toEqual([
{
name: '<NAME>',
mfgYear: 2020,
config: {
memory: 64
}
},
{
name: '<NAME>',
mfgYear: 2017,
config: {
memory: 32
}
},
{
name: 'Macbook Pro',
mfgYear: 2016,
config: {
memory: 16
}
},
{
name: 'XPS',
mfgYear: 2019,
config: {
memory: 8
}
}
]);
});
});
|
ffrancesc/absurdle.cat
|
src/lib/words.ts
|
import { WORDS } from "../constants/words";
import { Hint } from "./game";
export const isWordInWordList = (word: string) => {
return WORDS.includes(word.toLowerCase());
};
export const getHints = ({ word, guess }: { word: string, guess: string }): Hint[] => {
return Array.from(guess).map((char, i) => {
if (word[i] === char)
return "correct";
else if (word.includes(char))
return "present";
else
return "absent";
})
}
export const pruneWords = (words: string[], guess: string): string[] => {
let hash = (hints: Hint[]): string => {
return hints.map((hint) => {
switch (hint) {
case "correct": return "c";
case "absent": return "a";
case "present": return "p";
default: return "";
}
}).join("");
};
let bags: { [index: string]: string[]; } = {};
for (let word of words) {
const h = hash(getHints({ word, guess }));
let bag = bags[h] ?? [];
bags[h] = [...bag, word];
}
let largest: string[] = [guess];
for (const key in bags) {
const bag = bags[key];
if (bag.includes(guess))
continue;
else if (bag.length >= largest.length)
largest = bag
}
console.log(largest)
return largest;
}
|
ffrancesc/absurdle.cat
|
src/components/grid/Row.tsx
|
<filename>src/components/grid/Row.tsx
import { Hint } from "../../lib/game";
import { Cell } from "./Cell";
type Props = {
innerRef?: React.MutableRefObject<HTMLDivElement | null>;
guess: string;
hints?: Hint[];
};
export const Row = ({ guess, hints, innerRef }: Props) => {
const letters = Array.from(guess.padEnd(5))
return (
<div ref={innerRef} className="flex justify-center mb-1">
{letters.map((letter, i) => (
<Cell key={i} value={letter} hint={hints ? hints[i] : undefined} index={i}/>
))}
</div>
);
};
|
ffrancesc/absurdle.cat
|
src/components/mini-grid/MiniGrid.tsx
|
<filename>src/components/mini-grid/MiniGrid.tsx
import { Hint } from "../../lib/game";
import { MiniRow } from "./MiniRow";
type Props = {
hints: Hint[][];
};
export const MiniGrid = ({ hints }: Props) => {
return (
<div className="pb-6">
{hints.map((hint, i) => (
<MiniRow key={i} hints={hint} />
))}
</div>
);
};
|
ffrancesc/absurdle.cat
|
src/components/keyboard/Keyboard.tsx
|
import { Char, chars, KeyValue } from "../../lib/keyboard";
import { Key } from "./Key";
import { ReactNode, useEffect } from "react";
import { BackspaceIcon } from "@heroicons/react/outline";
type Props = {
onChar: (value: Char) => void;
onDelete: () => void;
onEnter: () => void;
disabledKeys: Set<KeyValue>;
};
const LAYOUT: KeyValue[][] = [
["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P"],
["A", "S", "D", "F", "G", "H", "J", "K", "L", "Ç"],
["Enter", "Z", "X", "C", "V", "B", "N", "M", "Backspace"],
];
const KEY_PROPS: { [key in KeyValue]?: { className?: string, children?: ReactNode } } = {
"Enter": { className: "w-20", children: "ENTER" },
"Backspace": {
className: "w-16", children: <BackspaceIcon className="h-6 w-6" />
},
};
export const Keyboard = ({ onChar, onDelete, onEnter, disabledKeys }: Props) => {
const onClick = (value: KeyValue) => {
switch (value) {
case "Enter": onEnter(); break;
case "Backspace": onDelete(); break;
default: onChar(value);
}
};
useEffect(() => {
const listener = (e: KeyboardEvent) => {
if (e.code === "Enter") {
onEnter();
} else if (e.code === "Backspace") {
onDelete();
} else {
const key = e.key.toUpperCase() as Char;
if (chars.includes(key)) {
onChar(key);
}
}
};
window.addEventListener("keydown", listener);
return () => {
window.removeEventListener("keydown", listener);
};
});
return (
<div className="pt-8 pb-0.5 px-0.5">
{LAYOUT.map((keyRow, i) => (
<div key={i} className="flex justify-center py-0.5">
{keyRow.map((key, j) => (
<Key
key={j}
value={key}
onClick={onClick}
disabled={disabledKeys.has(key)}
className={KEY_PROPS[key]?.className}
>
{KEY_PROPS[key]?.children}
</Key>
))}
</div>
))}
</div>
);
};
|
ffrancesc/absurdle.cat
|
src/components/mini-grid/MiniRow.tsx
|
import { Hint } from "../../lib/game";
import { MiniCell } from "./MiniCell";
type Props = {
hints: Hint[];
};
export const MiniRow = ({ hints }: Props) => {
return (
<div className="flex justify-center mb-1">
{hints.map((hint, i) => (
<MiniCell key={i} hint={hint} />
))}
</div>
);
};
|
ffrancesc/absurdle.cat
|
src/App.tsx
|
<filename>src/App.tsx<gh_stars>0
import { InformationCircleIcon, UserIcon } from "@heroicons/react/outline";
import { useState, useEffect } from "react";
import { Alert } from "./components/alerts/Alert";
import { Grid } from "./components/grid/Grid";
import { Keyboard } from "./components/keyboard/Keyboard";
import { AboutModal } from "./components/modals/AboutModal";
import { InfoModal } from "./components/modals/InfoModal";
import { WinModal } from "./components/modals/WinModal";
import { getHints, isWordInWordList, pruneWords } from "./lib/words";
import { WORDS } from "./constants/words";
import { KeyValue } from "./lib/keyboard";
import { Guess } from "./lib/game";
function App() {
const [guesses, setGuesses] = useState<Guess[]>([]);
const [disabledKeys, setDisabledKeys] = useState(new Set<KeyValue>())
const [currentWords, setCurrentWords] = useState(WORDS)
const [currentGuess, setCurrentGuess] = useState("");
const [isGameWon, setIsGameWon] = useState(false);
const [isWinModalOpen, setIsWinModalOpen] = useState(false);
const [isInfoModalOpen, setIsInfoModalOpen] = useState(false);
const [isAboutModalOpen, setIsAboutModalOpen] = useState(false);
const [isWordNotFoundAlertOpen, setIsWordNotFoundAlertOpen] = useState(false);
const [shareComplete, setShareComplete] = useState(false);
useEffect(() => {
if (isGameWon) {
setIsWinModalOpen(true);
}
}, [isGameWon]);
const onChar = (value: KeyValue) => {
if (currentGuess.length < 5) {
setCurrentGuess(`${currentGuess}${value}`);
}
};
const onDelete = () => {
setCurrentGuess(currentGuess.slice(0, -1));
};
const onEnter = () => {
if (currentGuess.length === 5) {
if (!isWordInWordList(currentGuess)) {
setIsWordNotFoundAlertOpen(true);
return setTimeout(() => {
setIsWordNotFoundAlertOpen(false);
}, 2000);
}
const guess = currentGuess.toLowerCase();
const nextWords = pruneWords(currentWords, guess);
const hints = getHints({ word: nextWords[0], guess });
hints.forEach((hint, i) => {
if (hint === "absent") {
setDisabledKeys(disabledKeys.add(currentGuess[i] as KeyValue))
}
});
setGuesses([...guesses, { guess: currentGuess, hints }]);
if (nextWords[0] === guess) {
setIsGameWon(true);
return;
}
setCurrentWords(nextWords);
setCurrentGuess("");
}
};
return (
<div className="h-full flex flex-col justify-between max-h-full">
<Alert message="Paraula no trobada" isOpen={isWordNotFoundAlertOpen} />
<Alert
message="Joc copiat!"
isOpen={shareComplete}
variant="success"
/>
<div className="flex min-w-2/4 mx-auto items-center mb-8 place-content-evenly">
<h1 className="text-2xl font-bold">ABSURDLE.CAT</h1>
<InformationCircleIcon
className="h-10 w-10 px-2 cursor-pointer"
onClick={() => setIsInfoModalOpen(true)}
/>
<UserIcon
className="h-10 w-10 px-2 cursor-pointer"
onClick={() => setIsAboutModalOpen(true)}
/>
</div>
<InfoModal
isOpen={isInfoModalOpen}
handleClose={() => setIsInfoModalOpen(false)}
/>
<AboutModal
isOpen={isAboutModalOpen}
handleClose={() => setIsAboutModalOpen(false)}
/>
<Grid guesses={guesses} currentGuess={currentGuess} />
<Keyboard
onChar={onChar}
onDelete={onDelete}
onEnter={onEnter}
disabledKeys={disabledKeys}
/>
<WinModal
isOpen={isWinModalOpen}
handleClose={() => setIsWinModalOpen(false)}
hints={guesses.map(({ hints }) => { return hints; })}
handleShare={() => {
setIsWinModalOpen(false);
setShareComplete(true);
return setTimeout(() => {
setShareComplete(false);
}, 2000);
}}
/>
</div>
);
}
export default App;
|
ffrancesc/absurdle.cat
|
src/constants/words.ts
|
<gh_stars>0
export const WORDS = [
"canot",
"gerna",
"unira",
"mogol",
"floco",
"valem",
"apomo",
"color",
"forat",
"vides",
"tibar",
"batan",
"actiu",
"ondos",
"gorra",
"poema",
"crear",
"ocult",
"oblit",
"legal",
"trama",
"culpa",
"rugir",
"farao",
"pedra",
"hiats",
"torra",
"exode",
"fleca",
"polpa",
"rigor",
"lloar",
"magia",
"sitar",
"aleia",
"ocult",
"lloau",
"obert",
"gorra",
"marca",
"usual",
"rural",
"trait",
"adint",
"glosa",
"oculs",
"pubil",
"amens",
"glose",
"piuar",
"obram",
"orbat",
"segol",
"resta",
"folls",
"aflac",
"acoti",
"gaste",
"entre",
"adesa",
"petjo",
"sanas",
"cimau",
"bascs",
"duler",
"diaca",
"untes",
"puigs",
"xutat",
"faiço",
"atzuf",
"rosti",
"borar",
"acori",
"seuen",
"aidat",
"xapam",
"resin",
"sacii",
"penes",
"jeure",
"entom",
"caiem",
"haveu",
"braol",
"odieu",
"entov",
"culpo",
"negau",
"ullis",
"romeu",
"jaent",
"pudit",
"adars",
"tibas",
"boris",
"soliu",
"raono",
"enseu",
"barat",
"humor",
"ocrea",
"cimer",
"llard",
"hapax",
"rosca",
"fires",
"perxe",
"ujare",
"micro",
"sureu",
"rigor",
"vares",
"pixas",
"amput",
"tauls",
"pispi",
"ribes",
"melos",
"barbs",
"brial",
"liles",
"bruta",
"ronyo",
"semal",
"taler",
"salsi",
"galze",
"nafil",
"rimer",
"vacau",
"drils",
"notin",
"desem",
"daria",
"sabat",
"culpe",
"soges",
"penas",
"jonic",
"nasal",
"redeu",
"adoni",
"volam",
"banyo",
"trepe",
"siset",
"fusta",
"xopam",
"pauta",
"ruscs",
"xucli",
"apomi",
"plagi",
"podis",
"budic",
"coxal",
"sioux",
"retop",
"oliam",
"barro",
"drape",
"alboc",
"patum",
"pisis",
"rapar",
"mofar",
"fidel",
"burat",
"aptes",
"grati",
"preso",
"candi",
"rapes",
"opili",
"opile",
"trita",
"napes",
"bagra",
"rosem",
"totxo",
"torra",
"doria",
"agarr",
"posta",
"desfa",
"casso",
"delat",
"altri",
"vetin",
"arper",
"remis",
"atics",
"gamam",
"deura",
"orlas",
"ungia",
"nombr",
"freda",
"pesau",
"manxu",
"ultre",
"mesis",
"summa",
"carde",
"sembr",
"epoca",
"orlin",
"resum",
"bario",
"preua",
"corde",
"liric",
"sipen",
"salti",
"boges",
"avila",
"hagen",
"avide",
"vagui",
"manec",
"iuans",
"gotzo",
"menta",
"valsa",
"repom",
"mocar",
"salmo",
"bombe",
"amina",
"borur",
"mesem",
"uquem",
"abdic",
"raser",
"menat",
"fraus",
"biteu",
"vetam",
"meses",
"silex",
"sofas",
"desca",
"fraro",
"eixat",
"venci",
"arens",
"rimel",
"solte",
"bequi",
"allop",
"agils",
"aspro",
"betza",
"rumbs",
"treps",
"obtus",
"bipar",
"dacro",
"eduit",
"atrau",
"durau",
"junye",
"xarol",
"velis",
"halat",
"depas",
"nansa",
"labor",
"aroil",
"gruta",
"gemim",
"criar",
"inies",
"sipos",
"xanca",
"taulo",
"rotam",
"fumos",
"abret",
"parar",
"adisc",
"retes",
"teles",
"eluia",
"opero",
"honra",
"aspir",
"malei",
"calle",
"azots",
"solia",
"damas",
"digne",
"vagiu",
"menar",
"metol",
"iries",
"gongs",
"votam",
"flaca",
"xelva",
"penys",
"corbi",
"bracs",
"fadeu",
"maneg",
"bramo",
"untin",
"escuo",
"aclot",
"dinal",
"seure",
"urgiu",
"polse",
"lobul",
"papen",
"guipo",
"invoc",
"acate",
"patin",
"triat",
"aterr",
"ruixi",
"folgo",
"papir",
"pedis",
"turba",
"casen",
"pagat",
"libin",
"flous",
"catio",
"fogal",
"sorti",
"giras",
"certa",
"cerot",
"xapis",
"copar",
"fixis",
"batut",
"palps",
"boral",
"doina",
"futil",
"olieu",
"alers",
"hiali",
"cacic",
"acoll",
"odiam",
"organ",
"anseu",
"boxau",
"lluia",
"antre",
"dener",
"retos",
"binam",
"lobus",
"imino",
"xumem",
"abism",
"munyi",
"crear",
"eduls",
"brecs",
"alocs",
"dines",
"etics",
"ferem",
"semin",
"prear",
"oiria",
"tacau",
"virin",
"gerdo",
"rodin",
"munts",
"sompa",
"sompo",
"camps",
"senys",
"farts",
"broma",
"toral",
"sollo",
"augur",
"ament",
"pruen",
"ovats",
"punti",
"ignis",
"caren",
"neveu",
"xapes",
"vagat",
"refaç",
"senal",
"birba",
"tiple",
"adone",
"esvai",
"toixo",
"perla",
"calet",
"tuege",
"fener",
"urpes",
"salda",
"ermam",
"galta",
"vedis",
"retut",
"nadeu",
"agito",
"divis",
"suber",
"ences",
"aleno",
"indri",
"sajol",
"parid",
"trots",
"flami",
"binis",
"pipin",
"ocupe",
"nedis",
"cuina",
"midis",
"aloma",
"areal",
"turma",
"rissi",
"rufia",
"sural",
"fosse",
"cerda",
"repti",
"midam",
"fugis",
"trona",
"veges",
"mamat",
"estan",
"negat",
"cuite",
"previ",
"vagar",
"mufin",
"mones",
"daura",
"coies",
"ungiu",
"sipem",
"cleca",
"tanes",
"polpa",
"saime",
"viuen",
"aidau",
"diols",
"amaça",
"mobla",
"lluin",
"tireu",
"talau",
"macla",
"tinta",
"embaf",
"domau",
"adarb",
"enver",
"peies",
"papeu",
"ultim",
"goles",
"pabul",
"omets",
"llanç",
"arets",
"cursi",
"elets",
"dauro",
"borau",
"feixe",
"obesa",
"puços",
"adond",
"radie",
"ratis",
"lumen",
"torre",
"atxim",
"jaupe",
"dalls",
"eixit",
"raima",
"ninou",
"ferla",
"malbo",
"avaro",
"tapio",
"arços",
"delta",
"arrog",
"patix",
"calga",
"niara",
"socia",
"sumit",
"ploro",
"radic",
"mapin",
"sumac",
"semat",
"birla",
"laxam",
"surti",
"xiula",
"gosas",
"roseu",
"amigo",
"colls",
"untor",
"lidar",
"cagam",
"votes",
"sumau",
"creti",
"sonsa",
"justo",
"pudim",
"adiem",
"xorcs",
"mostr",
"llimi",
"tines",
"redui",
"amarg",
"pesal",
"adorm",
"motiu",
"acaça",
"volts",
"baric",
"robor",
"salpi",
"tards",
"gabio",
"coper",
"gobid",
"votem",
"lluco",
"pitge",
"biret",
"sufoc",
"altre",
"anals",
"gonio",
"rigui",
"lutia",
"negue",
"rumor",
"veçar",
"belai",
"duram",
"balda",
"tamil",
"abjur",
"talpo",
"santo",
"alant",
"dadas",
"exult",
"atons",
"iresc",
"ploma",
"sanat",
"cesar",
"gabun",
"cuers",
"amolo",
"colze",
"gelat",
"desig",
"draga",
"viner",
"coana",
"esmoc",
"balir",
"derna",
"bagul",
"motlo",
"excus",
"firas",
"solga",
"feiem",
"xarop",
"pequi",
"sequi",
"cabeç",
"feble",
"penin",
"tenor",
"saben",
"furar",
"xamis",
"solid",
"coven",
"germa",
"sexin",
"raspo",
"labil",
"agenç",
"doric",
"ramut",
"ratin",
"atipl",
"dules",
"quede",
"arene",
"etens",
"arrap",
"brenc",
"conri",
"fluis",
"pisco",
"pelar",
"mapam",
"seues",
"cagar",
"xavos",
"sipes",
"voraç",
"eixos",
"capin",
"rodat",
"bodes",
"salvi",
"llesc",
"grapa",
"cisar",
"taxeu",
"afine",
"ajovo",
"gates",
"vinet",
"titot",
"surat",
"duras",
"rinya",
"fauna",
"dotes",
"podau",
"llimo",
"varam",
"quins",
"femes",
"prima",
"enram",
"peres",
"botam",
"escru",
"juste",
"mixta",
"roger",
"expir",
"talcs",
"ensac",
"onege",
"tofes",
"domta",
"poema",
"nigua",
"gebro",
"acces",
"culas",
"robam",
"hales",
"nuare",
"atupa",
"aedes",
"saurs",
"quart",
"xalar",
"ponxo",
"pelem",
"ulnar",
"esmin",
"pinxo",
"manar",
"batre",
"deiem",
"vegem",
"caids",
"urpeu",
"capim",
"alçar",
"pugin",
"manes",
"grufa",
"aurta",
"datam",
"oneig",
"exode",
"arçot",
"penge",
"atiin",
"erici",
"casse",
"uadis",
"morer",
"mamba",
"aquen",
"escot",
"piuen",
"botar",
"ostes",
"taxat",
"cleda",
"enras",
"asila",
"escoe",
"valer",
"desfe",
"ureic",
"tabid",
"pomar",
"fenye",
"ensus",
"lacto",
"gosat",
"carda",
"sella",
"galba",
"lluix",
"taxin",
"salts",
"untem",
"fanal",
"digit",
"quist",
"laxos",
"animo",
"caças",
"mitic",
"proes",
"fitau",
"gemix",
"eguer",
"gests",
"pomul",
"capsa",
"rasca",
"boceu",
"refiu",
"vicii",
"escum",
"nevar",
"tabic",
"atenc",
"sumat",
"votin",
"regui",
"ceris",
"encon",
"dicti",
"nebot",
"enjoi",
"mambo",
"educo",
"corfa",
"caçam",
"elevo",
"taula",
"visiu",
"sorgi",
"ferro",
"marli",
"grapo",
"ramem",
"bines",
"monso",
"races",
"fitar",
"ruflo",
"petar",
"aluda",
"perds",
"dogon",
"ullin",
"valia",
"alegi",
"indis",
"mulat",
"torca",
"ramau",
"joncs",
"figle",
"freni",
"arums",
"radia",
"maldo",
"falbs",
"agama",
"xevat",
"coqui",
"erolo",
"flors",
"fixas",
"tatxe",
"orlat",
"benei",
"llime",
"penna",
"carat",
"apleg",
"oleum",
"robar",
"alars",
"poden",
"llaga",
"zelis",
"guste",
"gitau",
"veten",
"xaire",
"bitis",
"eroga",
"serri",
"petin",
"socol",
"acnes",
"vireu",
"naspr",
"didal",
"pluto",
"carto",
"adeia",
"retor",
"paers",
"rinys",
"jaspi",
"sopas",
"furon",
"orlam",
"suris",
"ansia",
"atipe",
"delir",
"besuc",
"festi",
"veiem",
"mamin",
"obeit",
"gorgs",
"fumes",
"fucal",
"llufa",
"aneda",
"crano",
"raien",
"corns",
"vetis",
"xocau",
"lofid",
"cride",
"terna",
"visit",
"miolo",
"creen",
"dacia",
"costo",
"cluca",
"abats",
"solda",
"bocam",
"ibers",
"olgui",
"carni",
"colar",
"anima",
"acati",
"boiro",
"gasin",
"tegin",
"ajudi",
"brava",
"finit",
"rimau",
"afins",
"frene",
"piafe",
"pebre",
"rival",
"ningu",
"vapor",
"hisso",
"copal",
"galer",
"forta",
"tramo",
"urpas",
"nigul",
"bonic",
"eters",
"deneg",
"fotin",
"cofis",
"valls",
"farao",
"rugir",
"cedim",
"cames",
"furia",
"arree",
"sedan",
"luxar",
"arnot",
"redis",
"didim",
"atoms",
"pinti",
"brodo",
"lliço",
"oiada",
"rapia",
"refio",
"disto",
"pirat",
"capri",
"temen",
"pudin",
"zelin",
"inics",
"poara",
"fruia",
"boçam",
"coleu",
"fosca",
"atien",
"ruvet",
"finin",
"gogis",
"ovule",
"creuo",
"bogau",
"guill",
"tenis",
"xerif",
"ciara",
"visat",
"floti",
"dindo",
"trins",
"bleix",
"odiau",
"abacs",
"griot",
"apujo",
"poant",
"trenc",
"sutze",
"nuets",
"adorn",
"xafis",
"nauta",
"ossis",
"ungis",
"xarpe",
"zebus",
"ferum",
"cadet",
"alnes",
"barbe",
"xapos",
"boias",
"xurro",
"carie",
"helix",
"tepui",
"xiroi",
"thais",
"genal",
"bufeg",
"aleps",
"pogut",
"rendi",
"etile",
"ajeus",
"veleu",
"sipam",
"criat",
"ombri",
"atesa",
"cotno",
"medic",
"balmo",
"rodas",
"encet",
"absis",
"soies",
"feror",
"laxeu",
"films",
"embov",
"erers",
"davia",
"menau",
"fugen",
"colre",
"llufe",
"orine",
"fonat",
"brics",
"tomin",
"espic",
"plego",
"firat",
"pesin",
"finas",
"adams",
"bable",
"cafit",
"oiats",
"glauc",
"bocal",
"albir",
"sarda",
"traga",
"reixo",
"nervi",
"prenc",
"vincl",
"fiten",
"expos",
"ballo",
"recat",
"sondo",
"vinos",
"lloro",
"recoc",
"xotra",
"airau",
"efesi",
"lacai",
"trucs",
"poada",
"idees",
"suque",
"faent",
"eject",
"alabo",
"daven",
"fongs",
"robas",
"antes",
"laude",
"dures",
"iriem",
"penau",
"erals",
"boter",
"pavia",
"pelas",
"pelin",
"escau",
"pagin",
"ovins",
"berla",
"vegis",
"manas",
"entra",
"encas",
"obses",
"malts",
"astos",
"abato",
"guier",
"amils",
"saiga",
"cursa",
"corni",
"felus",
"xauti",
"nines",
"borda",
"ricor",
"dulia",
"anins",
"erole",
"eduim",
"creia",
"sorre",
"esput",
"aplic",
"sallo",
"embag",
"otics",
"inuit",
"perdo",
"joani",
"foscs",
"crits",
"silfs",
"boreu",
"reces",
"remar",
"etins",
"piqui",
"ajaem",
"runes",
"baixa",
"oreja",
"copis",
"balot",
"urgit",
"album",
"bolco",
"ogiva",
"monel",
"oireu",
"ajove",
"tonic",
"xagri",
"tinoi",
"penca",
"acote",
"adreç",
"gabas",
"soneu",
"serve",
"dinen",
"oblat",
"ileum",
"eixiu",
"ovala",
"triam",
"sarau",
"situo",
"sedeg",
"ligne",
"foses",
"sable",
"plapa",
"llops",
"glapi",
"oxida",
"fixau",
"furem",
"perdi",
"llosa",
"clapa",
"cuiti",
"bleda",
"petit",
"plane",
"minvo",
"intui",
"obsti",
"turca",
"ululo",
"deses",
"cigni",
"temeu",
"puput",
"copeo",
"acimo",
"lleto",
"rente",
"titet",
"petem",
"sacra",
"ermen",
"indic",
"rogic",
"recar",
"escul",
"visem",
"plena",
"briol",
"caper",
"nazis",
"bineu",
"navei",
"vença",
"cafis",
"diurn",
"gaseu",
"embog",
"marci",
"udole",
"danyi",
"bassa",
"tubet",
"embat",
"alara",
"veneu",
"xites",
"panet",
"paper",
"rafia",
"ofert",
"motes",
"creba",
"nomut",
"ramas",
"cocos",
"atrop",
"boxis",
"ploms",
"abate",
"ainat",
"litua",
"surra",
"unten",
"filla",
"libat",
"unens",
"tumor",
"tites",
"lloem",
"tapit",
"sipau",
"fumut",
"tueig",
"babel",
"golfs",
"veura",
"belem",
"goigs",
"mucic",
"eguin",
"libau",
"venut",
"erada",
"camfa",
"zelam",
"ainas",
"refem",
"gasto",
"mires",
"embal",
"aideu",
"sonen",
"volas",
"sostr",
"munio",
"farto",
"gairo",
"fonin",
"miosi",
"malai",
"lleve",
"vedau",
"marxa",
"afuau",
"aombr",
"letal",
"apats",
"llema",
"agusi",
"dente",
"premi",
"super",
"clota",
"gruid",
"lucre",
"rosas",
"gelas",
"xales",
"nones",
"caspa",
"rapel",
"efebs",
"begue",
"blasm",
"vogim",
"redic",
"oltes",
"istme",
"xafar",
"aguen",
"sares",
"ondul",
"voras",
"drama",
"fases",
"xopes",
"junys",
"pegar",
"eruct",
"sexen",
"zelos",
"vescs",
"ameri",
"bonir",
"duren",
"xaiem",
"ajoco",
"pugni",
"avile",
"rondo",
"balma",
"capos",
"xapol",
"geleu",
"torço",
"jurem",
"arris",
"mofat",
"campo",
"brull",
"eixia",
"gossa",
"rifem",
"daran",
"catre",
"puons",
"valva",
"alami",
"mofam",
"files",
"halar",
"mamem",
"coers",
"rugiu",
"xaves",
"solto",
"beoci",
"arrii",
"carta",
"pipis",
"enzim",
"pudel",
"gland",
"sense",
"cegam",
"grell",
"migra",
"olgue",
"huris",
"dotal",
"pagos",
"coses",
"rists",
"sulta",
"nivia",
"cavam",
"auixa",
"areni",
"godin",
"quita",
"xumin",
"pouin",
"pruiu",
"riuen",
"glati",
"rolla",
"estuf",
"ducar",
"guelf",
"xufar",
"abaca",
"agafa",
"llavo",
"iaios",
"umpls",
"llaca",
"xaria",
"ecoto",
"fumia",
"hajas",
"mormo",
"miram",
"agare",
"criis",
"piocs",
"rumie",
"bella",
"notas",
"nacta",
"gorri",
"cabla",
"fador",
"lluim",
"bavau",
"pirar",
"tepal",
"divan",
"xinen",
"porro",
"dansa",
"xerro",
"imams",
"passa",
"gosar",
"piulo",
"fitas",
"revol",
"unisc",
"borin",
"fotge",
"cueto",
"badis",
"llecs",
"menus",
"hereu",
"sedeu",
"desam",
"cullo",
"vetlo",
"malax",
"deieu",
"manti",
"ulnes",
"becar",
"fenga",
"xalem",
"semam",
"alare",
"vilte",
"trien",
"fedes",
"aldol",
"estat",
"fedal",
"masti",
"afano",
"edils",
"jaies",
"perix",
"glota",
"uquen",
"gitas",
"siula",
"crees",
"belis",
"aguam",
"mufam",
"sofre",
"alous",
"remoc",
"atuis",
"rebut",
"urpiu",
"notar",
"infla",
"peoni",
"tupau",
"irrog",
"bolic",
"zelat",
"bafor",
"fracs",
"imite",
"ciuro",
"devor",
"hajat",
"verms",
"sants",
"rings",
"savis",
"perfa",
"xitas",
"tomes",
"ullau",
"crues",
"nopal",
"verda",
"cante",
"margo",
"acera",
"rapir",
"faras",
"masos",
"gusla",
"vetla",
"tries",
"gitem",
"libra",
"rater",
"tiris",
"curso",
"mallo",
"azoic",
"regia",
"anode",
"balsa",
"xitin",
"tinto",
"xarpo",
"ustio",
"pruin",
"estim",
"menin",
"batis",
"rejos",
"plica",
"datil",
"orlar",
"cureu",
"viret",
"pages",
"uisse",
"guisc",
"poava",
"aleto",
"urpim",
"depen",
"perde",
"picor",
"vitet",
"omars",
"urpau",
"oblit",
"musen",
"flixi",
"volva",
"sapes",
"rodis",
"afona",
"culau",
"toliu",
"tesau",
"xaiau",
"calci",
"culpa",
"cofoi",
"aviem",
"befeu",
"cebua",
"sonet",
"optau",
"infam",
"dugis",
"glera",
"vella",
"periu",
"piris",
"ruixo",
"causa",
"lupes",
"murid",
"privo",
"gaspo",
"popes",
"dotas",
"maque",
"abrom",
"matar",
"delme",
"finco",
"forem",
"franc",
"celau",
"artec",
"baner",
"regle",
"mudin",
"rafes",
"fleix",
"peixa",
"viros",
"arreo",
"volto",
"calla",
"bouer",
"gener",
"fogat",
"mugir",
"afani",
"idoni",
"esmam",
"basta",
"ergol",
"ondam",
"bateu",
"caçat",
"llapo",
"bonit",
"citro",
"prats",
"urpem",
"escoo",
"missa",
"muscs",
"niats",
"tapar",
"pengi",
"cogut",
"erari",
"siria",
"sitja",
"fotre",
"flito",
"marga",
"santa",
"pensa",
"rupia",
"enfoc",
"dugue",
"troni",
"opilo",
"saima",
"panot",
"flama",
"nomes",
"atxul",
"caspi",
"alfil",
"lloma",
"taifa",
"calça",
"xafes",
"rotem",
"afues",
"unien",
"humit",
"manxs",
"pispa",
"vater",
"delmo",
"prens",
"torbe",
"gotza",
"noiem",
"ranis",
"rifau",
"bitin",
"cruio",
"vesem",
"cuixa",
"vinya",
"alcem",
"planc",
"nores",
"citen",
"cumul",
"canso",
"coati",
"varas",
"manos",
"desis",
"fuell",
"paire",
"pesta",
"osque",
"ubico",
"vogau",
"crido",
"surto",
"nevas",
"gaspa",
"laxin",
"aspre",
"pisos",
"copso",
"carpa",
"ancat",
"orsar",
"somou",
"poral",
"nevos",
"refet",
"aplat",
"lluny",
"volen",
"mimin",
"adust",
"curas",
"veloç",
"airas",
"boxem",
"alejo",
"posau",
"pauli",
"breva",
"orada",
"pasca",
"tofol",
"basic",
"prove",
"posas",
"musiu",
"jesus",
"viada",
"acron",
"lucra",
"torbi",
"brind",
"mutis",
"truja",
"nusos",
"cares",
"nafta",
"amola",
"traim",
"udola",
"tinya",
"somoc",
"bleir",
"hamza",
"rugix",
"cimem",
"ribas",
"atiar",
"prisi",
"nyaps",
"acamp",
"fames",
"finat",
"oncle",
"noema",
"raute",
"embec",
"actua",
"colau",
"pello",
"cavea",
"bufit",
"ataca",
"sacul",
"enten",
"rista",
"rapis",
"munte",
"fundo",
"neons",
"miols",
"gosen",
"hunes",
"esmem",
"sucos",
"minat",
"iques",
"aqued",
"arecs",
"xibiu",
"summe",
"succi",
"revis",
"polis",
"enmig",
"jauen",
"sedar",
"culpi",
"encel",
"femin",
"sirgo",
"tutor",
"vents",
"jacta",
"puges",
"batio",
"danya",
"banys",
"facto",
"estam",
"dents",
"ricar",
"ullot",
"ciris",
"acids",
"rapti",
"zelas",
"lucid",
"duiem",
"sufis",
"vicia",
"xapat",
"hajam",
"frego",
"sogre",
"rauco",
"untar",
"nansu",
"encen",
"solli",
"gogeu",
"plomo",
"topau",
"empro",
"quims",
"talin",
"duita",
"sipia",
"anant",
"paida",
"culte",
"batin",
"airat",
"urpit",
"emulo",
"comic",
"atreu",
"luxeu",
"capit",
"tombs",
"fresc",
"turcs",
"gafes",
"venti",
"clico",
"guapo",
"haver",
"damni",
"volum",
"rumen",
"eluis",
"gamin",
"idola",
"cadap",
"tatxa",
"comeu",
"tatuu",
"toles",
"matas",
"erris",
"fenyi",
"canço",
"galzo",
"cucat",
"mugix",
"maina",
"ombra",
"dopis",
"beril",
"begui",
"gaton",
"godua",
"hapte",
"dreço",
"basam",
"telar",
"turio",
"remud",
"jeieu",
"siclo",
"recau",
"provi",
"ulule",
"rapam",
"ondar",
"gires",
"entes",
"llits",
"trepi",
"fadem",
"murgo",
"uixos",
"foral",
"niers",
"billo",
"niera",
"acaro",
"milla",
"comet",
"baste",
"altra",
"tanya",
"mamus",
"vigiu",
"odore",
"eluix",
"ignia",
"teuto",
"acata",
"senda",
"matis",
"metil",
"punyo",
"vidia",
"dolls",
"coiot",
"pions",
"preis",
"vesso",
"cinic",
"godes",
"xamam",
"funyi",
"dalet",
"aviis",
"teurg",
"arruf",
"degot",
"pinço",
"orlen",
"renyi",
"tarde",
"gatin",
"uisso",
"obriu",
"ungle",
"negre",
"noses",
"palpi",
"xumet",
"rosau",
"furro",
"matxo",
"llevo",
"gibos",
"lloam",
"basto",
"psora",
"bogas",
"odiar",
"saqui",
"jaios",
"gemit",
"pilus",
"vitre",
"teflo",
"tusse",
"renda",
"munix",
"pirem",
"lagun",
"ermem",
"juncs",
"punic",
"serva",
"tomam",
"popen",
"lutis",
"dives",
"xeols",
"canid",
"entub",
"coura",
"varin",
"cinti",
"casos",
"sopar",
"metin",
"volti",
"denta",
"mesur",
"tanca",
"toria",
"zuaus",
"nugar",
"paixo",
"coteu",
"furti",
"inund",
"rapta",
"cudol",
"arpem",
"ajups",
"jeeps",
"potes",
"entin",
"halau",
"alert",
"gaies",
"mapen",
"ratas",
"forti",
"apell",
"limbe",
"femem",
"exina",
"amaci",
"dorca",
"fluix",
"raona",
"verra",
"sisal",
"punes",
"xibuc",
"saims",
"mongi",
"arria",
"fedai",
"crien",
"releg",
"atupo",
"anoll",
"bufam",
"cofre",
"manxi",
"croma",
"terço",
"jegui",
"occis",
"xinas",
"annex",
"allis",
"balia",
"realç",
"rauxa",
"ansin",
"acorr",
"tapau",
"esboc",
"clica",
"uvula",
"muigs",
"alies",
"llepo",
"actui",
"atzar",
"cosac",
"garso",
"domat",
"escac",
"filar",
"golfo",
"litis",
"doral",
"sapla",
"servi",
"garbo",
"cedit",
"inflo",
"galga",
"apamo",
"pugui",
"omeia",
"homes",
"grill",
"miris",
"trivi",
"aules",
"quico",
"desti",
"conys",
"xinat",
"acabo",
"clubs",
"gemec",
"xamem",
"moura",
"dopam",
"vidus",
"abund",
"etern",
"giric",
"dalla",
"oiara",
"mocat",
"neden",
"llego",
"xalau",
"irien",
"crina",
"invit",
"escup",
"arxiv",
"cincs",
"pedon",
"xatos",
"eixes",
"pilla",
"aziga",
"fixeu",
"fixat",
"crane",
"gamar",
"ratar",
"nomem",
"refeu",
"rateu",
"ordio",
"solau",
"finau",
"zones",
"segal",
"virau",
"tango",
"gebra",
"acils",
"emben",
"citri",
"raola",
"zincs",
"brumi",
"almud",
"dolor",
"nedat",
"totem",
"comit",
"afane",
"tauli",
"cofas",
"treim",
"jorda",
"endeg",
"ratem",
"capel",
"tells",
"polca",
"telin",
"pecar",
"irisa",
"insto",
"azigs",
"agrir",
"taros",
"escal",
"tibia",
"ablen",
"befar",
"embla",
"ronda",
"aidem",
"adora",
"encub",
"honro",
"nevis",
"tauja",
"potxo",
"uneix",
"renec",
"muden",
"dones",
"grogs",
"multi",
"alfac",
"afore",
"lesbi",
"eduir",
"paner",
"toric",
"brito",
"ometi",
"dropo",
"sexau",
"guerx",
"oposo",
"moral",
"poals",
"sumiu",
"arnes",
"civet",
"sello",
"freta",
"massa",
"gruer",
"dubta",
"verge",
"bujot",
"munia",
"giren",
"fossa",
"prems",
"sogar",
"tampo",
"urdus",
"nunci",
"trine",
"casin",
"atupe",
"alava",
"clous",
"bubis",
"roins",
"brome",
"xacat",
"guixo",
"boigs",
"xines",
"picas",
"frase",
"mancs",
"fades",
"nabab",
"plana",
"apany",
"remas",
"devem",
"munto",
"clori",
"retis",
"vegen",
"velen",
"psalm",
"agora",
"avens",
"senye",
"vaira",
"levic",
"cassa",
"fixem",
"perer",
"paste",
"rifar",
"mimen",
"xarra",
"gavia",
"franj",
"papes",
"binem",
"aclam",
"caven",
"sopem",
"optin",
"tudis",
"urpia",
"finta",
"varau",
"abril",
"nimia",
"folri",
"tenim",
"pelon",
"orgia",
"brisi",
"dries",
"himen",
"alics",
"sedes",
"obsto",
"bleim",
"armes",
"nadal",
"diman",
"molla",
"falço",
"xorro",
"simil",
"catxi",
"patro",
"podex",
"azims",
"colob",
"optem",
"belen",
"sonde",
"ajupi",
"toner",
"saliv",
"nords",
"burxe",
"tovot",
"agria",
"tudas",
"dolla",
"gamau",
"draps",
"tarta",
"peixi",
"clipi",
"remat",
"patac",
"rebol",
"afect",
"ferme",
"couro",
"dinat",
"cuido",
"bulli",
"bonet",
"pinso",
"arnos",
"raids",
"prior",
"julep",
"xuple",
"ajunt",
"trava",
"boals",
"pallo",
"envia",
"envid",
"deveu",
"aliin",
"jeiem",
"papar",
"vetle",
"bavat",
"gueta",
"cospi",
"danyo",
"rajam",
"vimet",
"domas",
"ciada",
"serio",
"sargs",
"quars",
"abuse",
"lamed",
"aries",
"gloms",
"clixe",
"osset",
"saneu",
"cabal",
"tabac",
"sofra",
"pelfi",
"estop",
"sumam",
"sonor",
"destr",
"ermas",
"guind",
"fures",
"corbs",
"cuafi",
"rates",
"rimen",
"blind",
"taqui",
"oliin",
"faixi",
"corba",
"votas",
"blans",
"mapau",
"bisen",
"blogs",
"midem",
"viara",
"peono",
"capat",
"tixin",
"bocis",
"pasta",
"assol",
"infim",
"danes",
"imito",
"abras",
"furis",
"llana",
"zebra",
"omega",
"uquis",
"luxat",
"quals",
"cimeu",
"infer",
"plets",
"estil",
"numer",
"fumis",
"ovari",
"lidia",
"cuejo",
"casco",
"cario",
"arbra",
"burxo",
"repus",
"horta",
"renov",
"nafre",
"preuo",
"ascli",
"molls",
"braça",
"mosta",
"helis",
"xinxa",
"bavos",
"clams",
"maços",
"rangs",
"flect",
"viren",
"afuse",
"blocs",
"ampli",
"xuixi",
"esver",
"hages",
"daics",
"tones",
"tomeu",
"cabut",
"escam",
"nanne",
"reial",
"rutes",
"mofis",
"fumam",
"clore",
"apiol",
"jotes",
"raons",
"fofes",
"comes",
"pugil",
"buixi",
"tinga",
"conco",
"pisas",
"bubes",
"punxi",
"sumen",
"vacar",
"decep",
"besos",
"xutar",
"sunna",
"tatos",
"ouada",
"dotin",
"acide",
"forge",
"orara",
"guite",
"basal",
"aprov",
"mofem",
"cucos",
"baciv",
"jutes",
"crupo",
"idear",
"futur",
"olius",
"cotxa",
"natge",
"paduc",
"meteu",
"cesse",
"rimin",
"aspia",
"poblo",
"pillo",
"porus",
"tempt",
"uniem",
"incus",
"dotam",
"isoet",
"fumas",
"aines",
"forni",
"caseu",
"levit",
"simul",
"tolen",
"doblo",
"acins",
"canut",
"bitau",
"grave",
"allit",
"calli",
"rasau",
"laica",
"samba",
"nedam",
"farci",
"volei",
"murex",
"erreu",
"variu",
"remes",
"sonam",
"sabes",
"dient",
"mamas",
"amoin",
"iodeu",
"tatue",
"escud",
"ritma",
"duple",
"avals",
"canal",
"addui",
"otica",
"arjau",
"boixe",
"ainin",
"venir",
"tapem",
"gunit",
"fules",
"xarri",
"bates",
"biseu",
"muflo",
"dinis",
"capem",
"anurs",
"manto",
"grifa",
"arpen",
"solfa",
"ansam",
"infon",
"laxat",
"acora",
"paler",
"acerb",
"micra",
"emesi",
"ambla",
"crisi",
"preem",
"orbem",
"infus",
"salms",
"marts",
"gansa",
"tremi",
"fogas",
"rouro",
"bugia",
"xacar",
"sabut",
"carra",
"migro",
"moixi",
"salao",
"veure",
"farda",
"enros",
"avoca",
"flame",
"fereu",
"xameu",
"amoms",
"bloom",
"sapid",
"volis",
"trina",
"caram",
"condo",
"dolga",
"landa",
"obrer",
"cagau",
"gireu",
"eleve",
"devia",
"mauro",
"salas",
"rifat",
"bisau",
"minyo",
"sotil",
"soste",
"malic",
"ucant",
"pesat",
"unflo",
"lliso",
"reobr",
"frust",
"aguda",
"topas",
"usual",
"osqui",
"dareu",
"boria",
"emboc",
"tocau",
"oloro",
"rumii",
"avids",
"nyoca",
"finam",
"lleix",
"acare",
"calmo",
"pairi",
"impos",
"esmen",
"acido",
"morla",
"acubo",
"embos",
"embol",
"xopis",
"cansa",
"olori",
"auixi",
"rulla",
"afila",
"valor",
"xauto",
"binas",
"molis",
"alcid",
"fotem",
"anisa",
"caira",
"malls",
"cedre",
"testa",
"giris",
"atots",
"amoni",
"mener",
"pipeu",
"terme",
"adula",
"russa",
"onden",
"lupus",
"vexam",
"voler",
"rapix",
"remen",
"tifus",
"espin",
"gatge",
"remor",
"estiu",
"garri",
"beveu",
"focus",
"aviar",
"udoli",
"llaur",
"runam",
"punia",
"beleg",
"botas",
"pixin",
"voleu",
"jamai",
"trito",
"polim",
"peseu",
"finim",
"arega",
"citau",
"henna",
"boiam",
"fenya",
"expia",
"velin",
"rosco",
"agres",
"cloia",
"cuell",
"armeu",
"grumi",
"tosso",
"rotic",
"napea",
"caieu",
"entoi",
"asens",
"encep",
"julls",
"xaute",
"amant",
"tudam",
"dosar",
"petes",
"sauri",
"aller",
"rajau",
"cimat",
"porra",
"jurin",
"seran",
"barri",
"toixa",
"paria",
"soldi",
"bogal",
"solde",
"teste",
"opini",
"mesin",
"sumeu",
"duris",
"voles",
"entec",
"danse",
"rampa",
"imbui",
"traus",
"xapem",
"rares",
"afono",
"aleig",
"guany",
"murar",
"cisau",
"rotau",
"morts",
"saupa",
"jugas",
"capau",
"broco",
"suava",
"movem",
"desou",
"uques",
"gamem",
"flote",
"sotgi",
"ansas",
"nouen",
"fadam",
"bocin",
"oeixs",
"nouer",
"popau",
"sarge",
"fugiu",
"espii",
"estub",
"norai",
"aspio",
"tesen",
"desen",
"duieu",
"padri",
"apreu",
"juies",
"jacto",
"enfit",
"sulid",
"feren",
"niero",
"encov",
"vogam",
"arrua",
"ganta",
"teina",
"regli",
"rasat",
"emani",
"bland",
"caves",
"reiem",
"agrix",
"mirri",
"metge",
"gemma",
"sufet",
"recam",
"halen",
"tauro",
"tibin",
"macau",
"etusa",
"tipus",
"manxo",
"cassi",
"canon",
"pupes",
"muras",
"cests",
"fugim",
"silil",
"proba",
"brido",
"agrit",
"elder",
"nicia",
"gosem",
"dosau",
"zonat",
"tendo",
"acres",
"girau",
"bevia",
"mineu",
"beura",
"ancor",
"vacas",
"sanau",
"brums",
"visau",
"embic",
"gemir",
"busca",
"pesam",
"pixam",
"altea",
"noris",
"rolle",
"ileal",
"plafo",
"treva",
"profa",
"plore",
"prema",
"punts",
"gluti",
"radar",
"vinic",
"puell",
"ideem",
"queta",
"vulva",
"aguar",
"mengi",
"apeti",
"sigut",
"eolit",
"untat",
"xotis",
"ondeu",
"oposa",
"monot",
"piras",
"telex",
"burjo",
"moreu",
"claca",
"celam",
"blets",
"mania",
"itric",
"oixen",
"amuro",
"totxa",
"gerga",
"motxo",
"galza",
"propi",
"tasca",
"vesis",
"creeu",
"eixam",
"aboli",
"aleni",
"oposi",
"curse",
"popeu",
"aspid",
"guara",
"sopen",
"ovuli",
"axial",
"pigat",
"arrug",
"abona",
"total",
"agars",
"clots",
"ruana",
"pedaç",
"bojac",
"peter",
"xafin",
"accio",
"cloni",
"cerva",
"genis",
"fluia",
"licit",
"teleu",
"firma",
"udols",
"dedal",
"niuet",
"fixar",
"petge",
"trinx",
"pansi",
"llita",
"popin",
"ultri",
"incis",
"aimia",
"cacis",
"vanas",
"miner",
"grips",
"ondas",
"crems",
"rails",
"castr",
"rauen",
"avalo",
"trave",
"ature",
"ronec",
"resos",
"calam",
"idols",
"raoni",
"orsat",
"pasto",
"luxis",
"picot",
"hules",
"enast",
"acali",
"tosco",
"gavet",
"rabec",
"motel",
"sever",
"xerra",
"lluen",
"cuixe",
"caduc",
"lloar",
"gruma",
"ubics",
"tombi",
"sedin",
"cagas",
"fulle",
"tarin",
"minso",
"sucub",
"alceu",
"enlla",
"tesis",
"llucs",
"desat",
"bronz",
"bixes",
"genui",
"vinil",
"rapem",
"patit",
"propa",
"adiat",
"clava",
"gnosi",
"nimfa",
"gruam",
"repto",
"verro",
"axons",
"mameu",
"boçar",
"mante",
"caire",
"sonem",
"setin",
"basin",
"mocas",
"paisa",
"parra",
"curra",
"salto",
"pitet",
"zencs",
"auria",
"casas",
"calçs",
"besar",
"opima",
"xamar",
"surar",
"sarga",
"doncs",
"aturo",
"frits",
"firmi",
"tocam",
"xolla",
"ubica",
"orsen",
"avisa",
"vessa",
"nugue",
"ciare",
"avero",
"peons",
"aflor",
"noesi",
"mente",
"cogui",
"molid",
"midin",
"putid",
"maner",
"gihad",
"tolue",
"espes",
"avisi",
"ralet",
"sereu",
"penic",
"burle",
"bonix",
"pelos",
"rifle",
"dugen",
"obvie",
"malla",
"safra",
"ronco",
"cutis",
"girem",
"aleta",
"traci",
"travi",
"azeri",
"refon",
"onzes",
"venjo",
"midat",
"immol",
"greda",
"liquo",
"bufas",
"azobe",
"xalas",
"amota",
"somer",
"gasti",
"treta",
"reble",
"tropa",
"vesse",
"sargi",
"barra",
"meulo",
"plers",
"empra",
"dolos",
"obeim",
"fiord",
"riure",
"aglif",
"volau",
"brivo",
"desas",
"clast",
"mimau",
"zeina",
"situu",
"apitx",
"cerns",
"sajos",
"arran",
"rulle",
"acuso",
"roman",
"caent",
"pincs",
"calze",
"podem",
"tridu",
"dobla",
"poare",
"amace",
"popis",
"tovor",
"nenes",
"optes",
"salar",
"topar",
"abell",
"crecs",
"fulls",
"frise",
"xiric",
"mofas",
"ullem",
"bambu",
"fogor",
"terre",
"minse",
"ralls",
"petri",
"focal",
"atipo",
"fogos",
"carin",
"nuesa",
"tifes",
"aliam",
"siuro",
"fisca",
"etica",
"hadal",
"sumin",
"benze",
"zefir",
"geliu",
"queda",
"dupla",
"elisi",
"aposo",
"muren",
"juren",
"valgs",
"oxide",
"tense",
"ginye",
"fulli",
"ocupi",
"broll",
"nitid",
"fisto",
"feieu",
"copta",
"gabre",
"rutll",
"motos",
"notat",
"cloca",
"tomem",
"bater",
"lemur",
"dioxa",
"fenil",
"oscau",
"exvot",
"llong",
"bulls",
"recel",
"fills",
"davem",
"penal",
"dares",
"anote",
"minau",
"atuit",
"ucada",
"faito",
"magma",
"obacs",
"rumia",
"saber",
"prise",
"aidam",
"preui",
"nubia",
"aixaf",
"ullar",
"occir",
"regiu",
"teule",
"eslip",
"brita",
"cists",
"ometo",
"nugas",
"fohns",
"ferri",
"torrs",
"budes",
"espir",
"podeu",
"tific",
"bivia",
"punix",
"aspes",
"pilor",
"caliu",
"ruina",
"trumf",
"iteri",
"gobit",
"fadat",
"recul",
"faria",
"trips",
"canya",
"ulleu",
"sosia",
"soper",
"seric",
"sabra",
"luxam",
"libic",
"brens",
"mofes",
"rotat",
"canto",
"raies",
"vesam",
"arcau",
"radii",
"heura",
"xurme",
"gruin",
"aturi",
"tella",
"bolla",
"dobli",
"droga",
"aixes",
"libeu",
"afill",
"asini",
"ordie",
"gumia",
"gronx",
"xurla",
"pitam",
"seixa",
"firin",
"xutin",
"quern",
"morco",
"midas",
"becam",
"xotxa",
"iodar",
"ondes",
"cento",
"oxidi",
"bifaç",
"dopin",
"ganga",
"raspa",
"ranxo",
"boiat",
"amnis",
"salol",
"llest",
"drupa",
"olesa",
"raone",
"sorns",
"avieu",
"hertz",
"burot",
"copau",
"visca",
"banjo",
"pixar",
"roges",
"cridi",
"posam",
"cueja",
"palms",
"patiu",
"cofau",
"pinxa",
"rient",
"ermot",
"gojam",
"bojos",
"pobra",
"mimeu",
"pilis",
"picar",
"ampro",
"telas",
"podes",
"cesso",
"dejun",
"xumen",
"rassa",
"cloeu",
"filam",
"empom",
"bleia",
"sansa",
"senet",
"gasta",
"sueva",
"salte",
"aceri",
"apure",
"gales",
"arada",
"batii",
"mufis",
"mirin",
"telen",
"espuç",
"hidro",
"gasca",
"vogas",
"macis",
"gerda",
"garsi",
"rique",
"clacs",
"acuda",
"vogat",
"afuso",
"tecla",
"encol",
"fotia",
"vexis",
"visos",
"buata",
"membr",
"beços",
"orles",
"exits",
"mideu",
"cines",
"aspri",
"erere",
"causi",
"tasto",
"nocio",
"goses",
"cotis",
"sucam",
"vaive",
"alçau",
"cigro",
"untet",
"trisc",
"clons",
"estas",
"folia",
"bleiu",
"acube",
"trono",
"ancia",
"salta",
"ethos",
"rojal",
"audaç",
"tareu",
"peita",
"corca",
"obits",
"taxas",
"copem",
"remem",
"xunga",
"aftes",
"saule",
"citar",
"piano",
"enarc",
"pilli",
"pampa",
"ermeu",
"alevi",
"entat",
"solem",
"trass",
"brost",
"opacs",
"lacra",
"folis",
"licor",
"ignot",
"vogis",
"talpa",
"enfic",
"gotim",
"capas",
"gelau",
"cugot",
"llija",
"dormi",
"ajupo",
"botos",
"daveu",
"apono",
"ordia",
"ornam",
"tuste",
"pedia",
"maldi",
"besin",
"immut",
"falto",
"caçar",
"obsce",
"vigia",
"copsi",
"bavem",
"tussa",
"varal",
"greus",
"ascis",
"alpax",
"ereri",
"lapse",
"donas",
"pelut",
"junts",
"freno",
"saiol",
"tarda",
"dorms",
"nomin",
"roure",
"enceb",
"veses",
"vagin",
"vedeu",
"nimbe",
"melga",
"surta",
"temor",
"sisca",
"radom",
"matam",
"adias",
"xubec",
"revif",
"cabra",
"salin",
"tonia",
"trias",
"brida",
"digui",
"afuis",
"babes",
"brins",
"mamut",
"ansar",
"podri",
"musem",
"foteu",
"cotxe",
"fareu",
"blava",
"liasa",
"pairo",
"mofin",
"ecoic",
"cruin",
"dimer",
"alene",
"bufau",
"filmi",
"envie",
"refil",
"avoco",
"sopat",
"urica",
"cores",
"gambi",
"edats",
"nodal",
"xifid",
"pouat",
"odiat",
"flasc",
"rebuf",
"rauta",
"vivim",
"onada",
"gites",
"grume",
"quito",
"filos",
"reteu",
"polip",
"xorca",
"fuits",
"burgs",
"enyor",
"peixo",
"lluiu",
"honre",
"aprim",
"piafs",
"defec",
"insta",
"magra",
"enfad",
"regor",
"pudor",
"nodri",
"gruen",
"pujol",
"curri",
"rojos",
"metec",
"dicta",
"finen",
"datar",
"xutes",
"desus",
"oscar",
"xames",
"sumes",
"sagus",
"balbi",
"capon",
"elogi",
"rosat",
"caixa",
"untau",
"abati",
"gomos",
"xeics",
"empat",
"trial",
"endut",
"boixo",
"rimeu",
"nodul",
"tenca",
"unesc",
"vagam",
"adeis",
"adapt",
"aures",
"abuix",
"depos",
"coste",
"evoca",
"glavi",
"fumau",
"rimat",
"binat",
"cerca",
"gespa",
"abrin",
"joule",
"precs",
"creua",
"sobte",
"xante",
"llite",
"inert",
"laxau",
"facem",
"estes",
"embas",
"gebri",
"brisa",
"orleu",
"neuma",
"natiu",
"piuam",
"paisc",
"boets",
"boxer",
"toris",
"marca",
"tirat",
"guino",
"duran",
"gomes",
"atrap",
"hauen",
"pluig",
"toros",
"fones",
"orsas",
"orval",
"midar",
"asclo",
"mapis",
"paint",
"parts",
"vetat",
"avein",
"mugiu",
"fenal",
"obvii",
"heret",
"mitat",
"cilis",
"durio",
"brode",
"hoste",
"burda",
"cries",
"pegue",
"xarpi",
"bocem",
"traço",
"asmes",
"quema",
"peucs",
"execr",
"encli",
"emblo",
"tiges",
"vials",
"plaça",
"olles",
"rifeu",
"teios",
"moqui",
"tolga",
"plora",
"llisa",
"fuset",
"rondi",
"mosso",
"colas",
"envin",
"milio",
"lacam",
"talus",
"anoto",
"abric",
"merda",
"segau",
"apona",
"mucos",
"tenço",
"jalon",
"ratxe",
"gemia",
"toiso",
"regno",
"naval",
"dinem",
"broti",
"deman",
"afany",
"aloes",
"erres",
"fauve",
"sopam",
"arilo",
"guien",
"rulls",
"irric",
"finiu",
"sonis",
"manya",
"reste",
"codes",
"orlem",
"birbe",
"donem",
"adixo",
"allun",
"feses",
"avilo",
"apome",
"fotos",
"regat",
"debit",
"sopit",
"dopat",
"cisam",
"vagos",
"fogue",
"meves",
"modol",
"tenen",
"asilo",
"lesiu",
"faqui",
"tapin",
"nevem",
"lleus",
"piseu",
"niell",
"esque",
"gelen",
"batia",
"sagaç",
"remuc",
"basat",
"matin",
"metal",
"labre",
"atens",
"gasat",
"obrin",
"temin",
"tanta",
"miula",
"torba",
"pujar",
"aviam",
"pilot",
"dogal",
"veuen",
"poues",
"ladan",
"sogau",
"auqui",
"vints",
"vesen",
"tuegi",
"ganxo",
"abord",
"clins",
"repla",
"tirin",
"gorda",
"xerpa",
"oleat",
"tibis",
"rasur",
"bavam",
"esqui",
"conya",
"treni",
"vions",
"conta",
"esmar",
"curro",
"adeus",
"sofri",
"lacar",
"goges",
"delit",
"tardi",
"gelis",
"acabi",
"bubal",
"digue",
"adits",
"agost",
"cints",
"muses",
"refos",
"paits",
"fadin",
"copat",
"aulet",
"gasar",
"belga",
"ragen",
"neves",
"esbat",
"inhal",
"porto",
"erbis",
"ajudo",
"lires",
"conra",
"virar",
"perxa",
"mines",
"rasin",
"tenso",
"pecas",
"semis",
"piuat",
"sumar",
"roini",
"boces",
"tanza",
"intim",
"mulli",
"popam",
"bobin",
"mapas",
"raime",
"mimes",
"rodeu",
"temes",
"torax",
"eixis",
"grufo",
"clona",
"cosis",
"xemic",
"xamen",
"arres",
"balme",
"aniso",
"flanc",
"gabes",
"glena",
"oreig",
"paira",
"denim",
"padro",
"nassi",
"vigil",
"rigut",
"menge",
"graus",
"jonça",
"vanta",
"velic",
"casem",
"aflat",
"fiter",
"dugin",
"rocol",
"barsa",
"oints",
"rebot",
"magic",
"alero",
"fonis",
"metgi",
"exerg",
"fogot",
"tants",
"fotes",
"gofro",
"toleu",
"escua",
"fitis",
"suput",
"ferim",
"volca",
"ujava",
"segar",
"betel",
"brami",
"acope",
"proti",
"oirem",
"tejus",
"tales",
"vinça",
"zelar",
"palar",
"maluc",
"molta",
"atxem",
"verol",
"quint",
"crida",
"calce",
"gusta",
"ameba",
"monya",
"monjo",
"folra",
"eluls",
"tudau",
"rades",
"enerv",
"pendo",
"nahua",
"belau",
"quedo",
"rames",
"xifre",
"triar",
"voteu",
"acimi",
"gamat",
"befem",
"virol",
"prosa",
"omete",
"tolia",
"morid",
"aviva",
"regau",
"agrer",
"retia",
"justa",
"gitam",
"reveu",
"denot",
"sorri",
"filmo",
"adesc",
"embli",
"noble",
"reseu",
"dedic",
"nuara",
"acace",
"murga",
"culin",
"sexam",
"pelle",
"solts",
"xicol",
"loess",
"cascs",
"botxa",
"fosos",
"atall",
"pireu",
"hexil",
"nivis",
"cuiro",
"boixi",
"guiam",
"dribl",
"bucle",
"corna",
"espuu",
"cucar",
"guard",
"balco",
"cueta",
"monja",
"xupes",
"nyiga",
"daves",
"alloc",
"nuvia",
"decor",
"expii",
"posat",
"majos",
"ginyo",
"sitis",
"cegat",
"afija",
"tasos",
"obenc",
"podam",
"relat",
"peten",
"fargo",
"ronde",
"dansi",
"volar",
"cocou",
"veniu",
"xilla",
"mosca",
"faxos",
"casor",
"xones",
"ocels",
"adona",
"gubia",
"fixin",
"exhum",
"solco",
"espeu",
"vibri",
"raval",
"sipas",
"errem",
"laser",
"gaigs",
"apilo",
"ample",
"sotal",
"bedui",
"robau",
"nyauf",
"aboni",
"puniu",
"fullo",
"ajaço",
"raucs",
"desix",
"dinin",
"anedo",
"ondau",
"bolda",
"campa",
"cisma",
"forum",
"borlo",
"sexta",
"volte",
"apaga",
"trens",
"retic",
"rotll",
"saimi",
"adarg",
"halam",
"tragi",
"calia",
"mudem",
"tiama",
"arnen",
"xumes",
"apeix",
"rompo",
"averi",
"segat",
"tonal",
"xafat",
"boxeu",
"dugui",
"deisi",
"cuera",
"pomes",
"isole",
"ensim",
"oidis",
"lloga",
"cosit",
"rages",
"trena",
"curio",
"olier",
"cesia",
"engol",
"oregi",
"piuau",
"direm",
"braga",
"orbeu",
"frigi",
"ratxa",
"esnov",
"amoto",
"roget",
"etoli",
"ordre",
"rudes",
"durem",
"mabre",
"sepia",
"conxi",
"urpar",
"llumi",
"homei",
"evita",
"atinc",
"varem",
"tabes",
"orbau",
"torna",
"trais",
"misto",
"parle",
"amere",
"tesos",
"agnom",
"pugne",
"greny",
"rifin",
"gosin",
"metro",
"regal",
"arpat",
"video",
"fumin",
"tarar",
"hifal",
"clono",
"jugat",
"brots",
"porga",
"cingl",
"orris",
"notem",
"tolit",
"pujos",
"bogui",
"orsau",
"cinta",
"llama",
"rolli",
"crins",
"gules",
"taris",
"batie",
"cerer",
"asseu",
"trist",
"vorer",
"fatos",
"llums",
"regas",
"ferix",
"filme",
"plecs",
"apego",
"moned",
"digau",
"resau",
"retxa",
"argue",
"sonau",
"orats",
"serre",
"boval",
"flixe",
"sials",
"arida",
"jaque",
"modic",
"covas",
"buros",
"agrum",
"esfen",
"adius",
"força",
"perua",
"taxon",
"gitar",
"soses",
"regan",
"logia",
"briva",
"cabet",
"ainam",
"bavar",
"aguso",
"gelin",
"sembl",
"boira",
"omplo",
"orals",
"mujol",
"diana",
"fiqui",
"visio",
"canse",
"tixes",
"acime",
"solod",
"polls",
"dujau",
"estov",
"aurto",
"gluma",
"senyi",
"tesem",
"balla",
"salsa",
"espuo",
"tiols",
"detin",
"boric",
"flair",
"basem",
"laxes",
"rufle",
"grony",
"sacie",
"lents",
"comis",
"mufar",
"breus",
"ionic",
"afile",
"carei",
"mules",
"sacar",
"acuba",
"sagal",
"punys",
"sanar",
"crans",
"copul",
"dicte",
"ganes",
"posem",
"afuen",
"gojar",
"noteu",
"metra",
"creme",
"entos",
"agami",
"bugon",
"basen",
"xinau",
"vults",
"recus",
"adieu",
"amole",
"culis",
"solta",
"cuter",
"demet",
"mireu",
"babau",
"acabe",
"bugre",
"nicis",
"naips",
"aguem",
"seros",
"priva",
"folre",
"dedui",
"tomen",
"tarat",
"duars",
"esgol",
"pujam",
"lassa",
"orons",
"grams",
"corbe",
"aille",
"timus",
"damno",
"irieu",
"dopen",
"parva",
"auros",
"rimis",
"nuats",
"empal",
"coveu",
"txeca",
"llues",
"forço",
"mudam",
"baina",
"xampu",
"ainis",
"cosiu",
"eixug",
"priso",
"model",
"penta",
"tecal",
"marer",
"nocam",
"rigue",
"aboio",
"tolir",
"vener",
"llisc",
"clans",
"umbra",
"falle",
"escat",
"furra",
"cofen",
"urpin",
"minio",
"afeix",
"aides",
"rello",
"campe",
"utils",
"avivi",
"terra",
"ofens",
"desin",
"odiin",
"alcio",
"libam",
"ramos",
"moveu",
"baliu",
"rossa",
"farem",
"espat",
"ponis",
"urgix",
"barre",
"pelfe",
"domes",
"ponia",
"julis",
"bigal",
"corre",
"reple",
"filma",
"atura",
"teniu",
"rodar",
"lliga",
"mirra",
"erero",
"unteu",
"oquer",
"sigui",
"colon",
"tupar",
"cicle",
"delga",
"gerra",
"niant",
"rolls",
"venes",
"amava",
"imago",
"pudir",
"apami",
"etali",
"altiu",
"beleu",
"poueu",
"farro",
"habil",
"lluis",
"ondin",
"arees",
"cloti",
"roves",
"onejo",
"fiats",
"purna",
"afora",
"acord",
"guant",
"ratll",
"mimar",
"sagne",
"vatua",
"muria",
"matem",
"oment",
"embut",
"cigne",
"funda",
"flocs",
"obcec",
"orina",
"croca",
"apile",
"caces",
"rediu",
"clusa",
"camat",
"regar",
"clero",
"nedeu",
"quera",
"tuits",
"campi",
"altiv",
"edeta",
"tixri",
"afixi",
"doneu",
"gravi",
"aspie",
"renoc",
"mufes",
"colzo",
"denou",
"botat",
"macip",
"tubul",
"calua",
"engat",
"xebro",
"atacs",
"etzib",
"dutxa",
"podia",
"triem",
"palma",
"pedat",
"uquin",
"mimis",
"aurte",
"erets",
"ajovi",
"bingo",
"dipol",
"xitau",
"filii",
"carpo",
"piafo",
"vicie",
"sondi",
"muniu",
"balan",
"afegi",
"mirat",
"alisa",
"oxina",
"encer",
"sacsa",
"repar",
"rimem",
"befes",
"xalen",
"urgis",
"emmat",
"solcs",
"maigs",
"viscs",
"opere",
"nimis",
"titul",
"moira",
"revoc",
"gaiol",
"concs",
"certs",
"llamp",
"cures",
"nodos",
"datin",
"entel",
"clape",
"llegi",
"libes",
"porcs",
"repap",
"foten",
"ariet",
"tapet",
"itero",
"triis",
"bolli",
"datem",
"anoes",
"sagna",
"cards",
"unces",
"oblic",
"alera",
"manco",
"blaus",
"tamis",
"tebeo",
"picau",
"drene",
"pruna",
"nacre",
"desau",
"peixe",
"mudau",
"adobe",
"mamis",
"muris",
"traix",
"odias",
"ignar",
"espio",
"virat",
"trigo",
"gerro",
"anhel",
"trauc",
"pinxe",
"cerco",
"aliar",
"jaqui",
"afart",
"tusto",
"marit",
"ovals",
"dring",
"sedos",
"catar",
"clame",
"dolam",
"adien",
"recal",
"fencs",
"coure",
"colps",
"pater",
"xamin",
"salve",
"gebre",
"vuite",
"grufe",
"furas",
"gicar",
"cauen",
"caura",
"gneis",
"nogut",
"devon",
"griso",
"talem",
"armar",
"pixis",
"acurt",
"negus",
"porco",
"empes",
"fotja",
"marge",
"rapit",
"fumer",
"escoa",
"amats",
"delia",
"apnea",
"mudat",
"junça",
"farta",
"guits",
"nyora",
"tutel",
"etims",
"fetor",
"polir",
"popar",
"foies",
"probe",
"closa",
"cadaf",
"casts",
"surer",
"paesc",
"topeu",
"vogiu",
"cresp",
"ondis",
"cobro",
"cloem",
"bonim",
"etans",
"afrau",
"cegue",
"aidas",
"mirro",
"femti",
"girat",
"caues",
"cotas",
"hagim",
"regel",
"ronya",
"atuir",
"bevem",
"caiac",
"penem",
"avies",
"xenes",
"aguse",
"rimar",
"rumba",
"llist",
"jaces",
"creat",
"gabem",
"fruix",
"tocat",
"prims",
"breto",
"golfa",
"cents",
"catxa",
"medis",
"renya",
"heuen",
"embot",
"brega",
"mogut",
"mussa",
"alduf",
"amist",
"titit",
"atias",
"ficta",
"claps",
"junci",
"cadis",
"ardat",
"clora",
"claco",
"macul",
"pacto",
"sulla",
"sutur",
"viric",
"topem",
"fango",
"domus",
"docte",
"cohob",
"pujau",
"guiin",
"pitjo",
"sutja",
"grape",
"cardo",
"fonga",
"vivid",
"faves",
"cisem",
"pixau",
"arbro",
"degue",
"lapid",
"barca",
"calas",
"txecs",
"ansau",
"brusi",
"comam",
"fiteu",
"popem",
"trops",
"persa",
"boiar",
"enjub",
"abura",
"dauri",
"xinam",
"molat",
"edite",
"basca",
"vetli",
"bimba",
"urpen",
"colpi",
"colia",
"zeids",
"crons",
"advoc",
"fotil",
"pouis",
"dosem",
"legat",
"laxar",
"xares",
"uters",
"vivor",
"agret",
"apano",
"blada",
"garba",
"pifia",
"volia",
"narro",
"creim",
"traiu",
"unfla",
"culat",
"colro",
"drena",
"meten",
"datas",
"pigre",
"somia",
"corbo",
"motle",
"mucus",
"sigma",
"birma",
"capir",
"tanga",
"noval",
"semau",
"afuem",
"xacos",
"anyil",
"grano",
"vanis",
"banya",
"meles",
"cises",
"ileus",
"rober",
"tubes",
"saucs",
"creem",
"merce",
"irats",
"tocas",
"digen",
"pollo",
"aital",
"talio",
"passe",
"botim",
"pouen",
"romes",
"gaben",
"arboç",
"abrus",
"polar",
"bosca",
"nuils",
"obvia",
"serro",
"hagui",
"adita",
"nabis",
"diras",
"bandi",
"placa",
"dinde",
"calfe",
"elles",
"finor",
"avesa",
"sangs",
"dateu",
"fiblo",
"talar",
"iriso",
"tores",
"safes",
"punye",
"perir",
"ruecs",
"vogue",
"virio",
"folie",
"pites",
"peces",
"arbri",
"biela",
"narre",
"spins",
"freds",
"pelfo",
"flums",
"diens",
"panic",
"redit",
"cloga",
"elevi",
"fotic",
"milit",
"covin",
"sorna",
"sucau",
"rapin",
"gofra",
"lacre",
"escut",
"senar",
"preeu",
"gaiat",
"domis",
"enred",
"sanin",
"molem",
"pates",
"comar",
"nomia",
"faixa",
"igual",
"vaqui",
"penia",
"aboie",
"fuses",
"pouar",
"modes",
"citis",
"gruat",
"aplaç",
"orsem",
"amoti",
"alada",
"estol",
"elits",
"peany",
"jades",
"marid",
"tunid",
"batem",
"coieu",
"gents",
"minvi",
"olore",
"merla",
"firme",
"sinoc",
"cabre",
"hamer",
"astor",
"guita",
"ailla",
"merit",
"mesar",
"aplet",
"deleg",
"punyi",
"retxe",
"frecs",
"vedic",
"licao",
"imant",
"discs",
"molas",
"botem",
"satir",
"gassa",
"bisem",
"mimas",
"dixis",
"prest",
"posts",
"luxau",
"farot",
"parit",
"donis",
"signa",
"furts",
"atees",
"broix",
"cenes",
"separ",
"opims",
"fonye",
"pegos",
"espet",
"crebe",
"ornis",
"feria",
"perna",
"unida",
"siena",
"gicam",
"pilar",
"debut",
"errat",
"limba",
"feina",
"pinsa",
"sedis",
"expes",
"comte",
"vedet",
"lisos",
"gavid",
"forte",
"taras",
"munda",
"troba",
"ferra",
"obrau",
"paios",
"ceres",
"xupli",
"ficte",
"napia",
"ronsa",
"famos",
"xamba",
"palto",
"posar",
"aliau",
"gnoms",
"oliau",
"anual",
"cavil",
"crebo",
"rodem",
"optar",
"bitas",
"uissa",
"guiis",
"tares",
"roben",
"roina",
"romas",
"jumel",
"riscs",
"calao",
"folga",
"tombe",
"ragem",
"tenyi",
"polle",
"opten",
"malbe",
"cosco",
"cacau",
"rogle",
"malsa",
"arena",
"cosso",
"domto",
"casca",
"vesat",
"resso",
"deban",
"suera",
"bifia",
"braus",
"penet",
"degut",
"refer",
"papin",
"jaupa",
"pudos",
"mirem",
"allic",
"pacte",
"pepes",
"tolim",
"ambre",
"vivaç",
"rasen",
"sinia",
"siris",
"potil",
"orell",
"croms",
"peier",
"piafi",
"tambe",
"salla",
"exces",
"tsars",
"grueu",
"dotze",
"sipin",
"escor",
"poros",
"amoix",
"infix",
"gusto",
"vessi",
"pilos",
"llati",
"pecat",
"baila",
"faldo",
"reven",
"esgot",
"resis",
"decau",
"lepto",
"acurç",
"penja",
"roleu",
"arrel",
"besis",
"preme",
"lilos",
"decil",
"apexs",
"ratat",
"anorc",
"peros",
"ribot",
"trair",
"bodis",
"afaen",
"hampa",
"forja",
"sudes",
"emble",
"acoto",
"censa",
"gasos",
"branc",
"canta",
"oscat",
"rellu",
"sitra",
"lleem",
"mufau",
"biter",
"fugaç",
"clavi",
"dalts",
"besat",
"naixe",
"rueca",
"multa",
"capis",
"unfli",
"prona",
"mamau",
"xolls",
"lunar",
"maies",
"galls",
"depil",
"bards",
"canet",
"teula",
"raves",
"salic",
"durin",
"renti",
"hurra",
"hidra",
"esmau",
"molts",
"dalia",
"plors",
"ateny",
"ofusc",
"borni",
"clote",
"ultra",
"gloso",
"editi",
"avida",
"acany",
"daure",
"rague",
"moriu",
"reixs",
"abaix",
"venga",
"trits",
"encis",
"cendr",
"ponte",
"clari",
"enula",
"llepi",
"tises",
"temia",
"talat",
"bussi",
"frese",
"soleu",
"evols",
"eviti",
"cuada",
"abois",
"quest",
"gruas",
"urgim",
"jupes",
"bassi",
"quecs",
"grecs",
"paies",
"titub",
"arrim",
"etiop",
"canyo",
"tomba",
"poder",
"emigr",
"sexas",
"atent",
"capiu",
"llaça",
"alter",
"orses",
"peull",
"obrim",
"titil",
"filia",
"feral",
"magia",
"tresi",
"oiava",
"ajoca",
"tavec",
"becfi",
"oidor",
"rufli",
"xuteu",
"gabar",
"femur",
"xocat",
"ulval",
"alabi",
"xitem",
"verna",
"taste",
"posit",
"romps",
"carns",
"trufe",
"avial",
"fasic",
"fresi",
"folle",
"sobto",
"alats",
"furta",
"ducat",
"lones",
"vacun",
"orsis",
"torts",
"cales",
"xinin",
"sapan",
"vedin",
"rotas",
"segam",
"linxi",
"tauri",
"orneu",
"iotes",
"vagil",
"voxel",
"anell",
"tunel",
"agamb",
"adies",
"aixol",
"floro",
"daica",
"datiu",
"amada",
"ajaga",
"picon",
"gamba",
"acopo",
"burxi",
"nival",
"zirco",
"bulla",
"manat",
"afuam",
"titol",
"dolau",
"nociu",
"entri",
"actor",
"carro",
"durat",
"samec",
"drons",
"avali",
"obeis",
"venia",
"pompo",
"tuden",
"regul",
"ermes",
"vitel",
"bauxa",
"airem",
"lotus",
"oromo",
"diste",
"pelat",
"boton",
"boxar",
"pidol",
"teies",
"notis",
"cavum",
"neret",
"jague",
"refas",
"citeu",
"sagni",
"calfi",
"badge",
"flams",
"fumat",
"panna",
"enjov",
"fonic",
"dacsa",
"cromo",
"pilon",
"arrea",
"opaca",
"multo",
"ponem",
"ruacs",
"arrib",
"diria",
"doiut",
"lluus",
"vexes",
"tenda",
"fello",
"rebre",
"odiis",
"paors",
"tosse",
"xurmo",
"testi",
"mufti",
"rumio",
"adiga",
"tolla",
"opina",
"vires",
"fesos",
"neixo",
"faver",
"mirre",
"mesas",
"betol",
"modem",
"vague",
"sacsi",
"roteu",
"rotin",
"avars",
"rimes",
"lacat",
"ideal",
"cobla",
"avall",
"cauet",
"viudo",
"blanc",
"llots",
"acala",
"ixies",
"oblid",
"nyepa",
"oides",
"coxes",
"judic",
"pelli",
"ninot",
"adiis",
"beses",
"xopar",
"untam",
"cotna",
"piric",
"gamma",
"espue",
"booms",
"feixa",
"degui",
"obris",
"odeon",
"lanta",
"alaga",
"anisi",
"amure",
"pelea",
"tiofe",
"airos",
"empel",
"llord",
"menja",
"mujos",
"hedra",
"bitll",
"aromo",
"tutus",
"agiti",
"boxes",
"llito",
"mocos",
"faiso",
"naixi",
"bojal",
"orins",
"clave",
"jureu",
"vesar",
"coces",
"carbo",
"rocos",
"rompe",
"obrar",
"retem",
"vigis",
"clips",
"bancs",
"peiro",
"xambo",
"sorda",
"bantu",
"pedro",
"gicas",
"badoc",
"estar",
"niada",
"bruns",
"deien",
"sonin",
"toler",
"polps",
"ideat",
"belas",
"gobis",
"barba",
"mesau",
"llenç",
"guieu",
"talos",
"varar",
"pelam",
"bronc",
"accis",
"arter",
"semes",
"osmis",
"bafia",
"renom",
"peris",
"escas",
"dosen",
"tutes",
"fondo",
"tiara",
"aduno",
"menes",
"confi",
"refan",
"casal",
"aspis",
"ofita",
"marxe",
"arrie",
"diari",
"lasco",
"adret",
"meuca",
"poneu",
"retre",
"empip",
"temis",
"anura",
"daixo",
"denes",
"grumo",
"talis",
"corts",
"recta",
"agafe",
"xaval",
"cediu",
"tomar",
"xafen",
"colla",
"polit",
"pudia",
"pique",
"abste",
"clucs",
"grapi",
"traeu",
"golut",
"haima",
"acloc",
"anyal",
"minas",
"dujar",
"bruix",
"rasco",
"junyi",
"notam",
"colen",
"fugat",
"dureu",
"fugia",
"taxen",
"torco",
"solle",
"ocios",
"crome",
"danye",
"olors",
"meseu",
"pruim",
"suada",
"picta",
"nugui",
"aucas",
"cueig",
"glast",
"filin",
"monge",
"pobli",
"amela",
"conre",
"llofr",
"maces",
"autor",
"acano",
"fotgi",
"pugem",
"altes",
"perol",
"cisat",
"genet",
"rosec",
"negui",
"oscam",
"crato",
"rugos",
"ameli",
"deute",
"enfil",
"niare",
"badas",
"xapar",
"aties",
"copes",
"vages",
"gelam",
"gogem",
"luxem",
"duels",
"sulfa",
"pudus",
"taxis",
"ulula",
"escap",
"setet",
"ullen",
"gigre",
"rufla",
"estai",
"grufi",
"logic",
"musos",
"caror",
"jutgi",
"aixec",
"talam",
"brunz",
"nariu",
"alqui",
"corro",
"orini",
"vasts",
"seste",
"neuli",
"salde",
"furga",
"conro",
"ixent",
"dreta",
"falli",
"pavon",
"larva",
"miren",
"dosos",
"beles",
"busos",
"ajorn",
"imita",
"saure",
"odoro",
"brise",
"paula",
"envet",
"pariu",
"pague",
"rases",
"marbr",
"busts",
"balba",
"ioden",
"algun",
"ardor",
"oliem",
"civil",
"atona",
"ginys",
"semas",
"bossa",
"pleta",
"caixo",
"queca",
"cotes",
"valeu",
"arabs",
"recou",
"suros",
"pruis",
"xarxo",
"arnia",
"placi",
"dingo",
"gruix",
"arxiu",
"fible",
"embus",
"sanen",
"plous",
"embon",
"felid",
"aguin",
"doler",
"algid",
"odiem",
"fenar",
"colzi",
"alieu",
"orfeo",
"preat",
"arbor",
"posin",
"moher",
"ovuls",
"bateo",
"airen",
"selva",
"dotat",
"borla",
"ferin",
"ozons",
"pipam",
"agros",
"rebat",
"bisos",
"puces",
"femte",
"peses",
"icors",
"colta",
"pirop",
"situi",
"encar",
"pinça",
"ficar",
"pisem",
"joliu",
"folio",
"brufa",
"gisco",
"vasos",
"rasas",
"furto",
"putes",
"angel",
"luxes",
"menas",
"dineu",
"tetol",
"sogas",
"dhals",
"saput",
"mufeu",
"befas",
"dodos",
"alque",
"roseg",
"ermat",
"camin",
"picte",
"imina",
"serac",
"avara",
"sotol",
"morma",
"rocam",
"truca",
"vogix",
"fruim",
"xauta",
"epics",
"lepra",
"fonyo",
"casot",
"zelau",
"sipeu",
"apode",
"pudis",
"pioca",
"olora",
"zelem",
"doris",
"finto",
"vitri",
"ornen",
"imput",
"mesen",
"porci",
"petja",
"piuas",
"iodem",
"nafro",
"acots",
"puats",
"grafs",
"recte",
"sumim",
"xucle",
"tisis",
"amide",
"huits",
"flite",
"borli",
"cover",
"gaubo",
"urpam",
"petis",
"colur",
"reull",
"corms",
"facen",
"caber",
"triac",
"musti",
"xumat",
"olios",
"nards",
"bufal",
"gesta",
"curem",
"orbes",
"lacas",
"comau",
"aforo",
"clapi",
"veins",
"suant",
"furin",
"esdui",
"aflam",
"pisau",
"tanye",
"noieu",
"hifes",
"grifi",
"acore",
"palli",
"picat",
"capta",
"reque",
"balbo",
"guiti",
"regna",
"sodic",
"rests",
"neros",
"darde",
"fitat",
"torro",
"adese",
"acato",
"runic",
"etnia",
"bolle",
"covem",
"apana",
"funde",
"malde",
"xicot",
"salau",
"aroma",
"paput",
"decim",
"morra",
"oneja",
"finem",
"exili",
"surin",
"mofeu",
"edema",
"cuics",
"xufer",
"assut",
"cairo",
"borms",
"pruir",
"bufes",
"ozena",
"gutxo",
"ments",
"pinos",
"pareu",
"votis",
"glaço",
"delfi",
"acudi",
"exigi",
"gasas",
"ovalo",
"piram",
"ascia",
"mamam",
"ossos",
"clamo",
"jutjo",
"agrim",
"viviu",
"beats",
"bisam",
"suram",
"impiu",
"mocio",
"minia",
"diran",
"tendi",
"murri",
"finca",
"tronc",
"carla",
"accia",
"vacci",
"lloas",
"drago",
"trepo",
"huite",
"noure",
"cubit",
"iodic",
"minve",
"ratel",
"excit",
"baldo",
"eluit",
"ursid",
"rebra",
"citam",
"acudo",
"trido",
"veent",
"rugis",
"norma",
"firen",
"estos",
"larid",
"culam",
"cavim",
"lasse",
"gruny",
"bando",
"mento",
"xamau",
"enarç",
"musin",
"xinar",
"quadr",
"cimen",
"avino",
"ullat",
"obaga",
"predi",
"lesio",
"suren",
"pisto",
"aduni",
"doles",
"statu",
"fumic",
"octes",
"culet",
"cagat",
"dopes",
"rosta",
"perda",
"virem",
"caben",
"plint",
"xaleu",
"repos",
"valua",
"munir",
"dinau",
"cotid",
"ondat",
"aferr",
"tirem",
"ampit",
"emuli",
"muons",
"aromi",
"gaubi",
"becat",
"giqui",
"fadri",
"aviau",
"radio",
"fagot",
"nadas",
"esfum",
"fermo",
"capço",
"segue",
"sorus",
"sines",
"saial",
"celic",
"juras",
"jurca",
"suaus",
"cuege",
"multe",
"tueja",
"baves",
"pesco",
"robis",
"fugir",
"sacau",
"munit",
"lexic",
"ucava",
"retxi",
"oscas",
"fiola",
"banco",
"parec",
"gogen",
"ajeim",
"vexas",
"vegin",
"bitxo",
"psoes",
"rents",
"firmo",
"revel",
"obres",
"mills",
"acari",
"troto",
"tensa",
"pises",
"cocul",
"usura",
"badau",
"torto",
"ceros",
"veces",
"orbit",
"nevin",
"abans",
"lluor",
"xumeu",
"bocoi",
"bugiu",
"boual",
"segla",
"regni",
"ovulo",
"nedas",
"arpes",
"sapia",
"elois",
"cusen",
"nodes",
"linxe",
"polze",
"vairs",
"momia",
"paris",
"revir",
"punim",
"nirvi",
"clima",
"pivot",
"terbi",
"nimbi",
"auges",
"expio",
"sagin",
"treno",
"randa",
"fumeu",
"calmi",
"colra",
"broda",
"vione",
"ornem",
"aflux",
"vence",
"quite",
"llepa",
"greja",
"drapi",
"polla",
"gerla",
"inste",
"sauna",
"actes",
"dinar",
"gauba",
"efods",
"acara",
"tapat",
"legal",
"ciats",
"truco",
"cisas",
"delim",
"arpis",
"trams",
"piafa",
"sacso",
"filen",
"picam",
"cagui",
"falsa",
"agape",
"femen",
"arrue",
"xaica",
"borro",
"cotne",
"cossi",
"melat",
"roten",
"cords",
"fossi",
"docil",
"penso",
"vaque",
"halas",
"nedes",
"sexeu",
"ocupo",
"colts",
"acatx",
"crias",
"gaspe",
"orxeg",
"copii",
"amari",
"birbo",
"vicis",
"binen",
"ainau",
"ampri",
"colca",
"besas",
"pruit",
"humus",
"geste",
"guito",
"ovina",
"colga",
"ordit",
"avenç",
"cabas",
"girar",
"breny",
"prees",
"monte",
"xutas",
"bifid",
"fatua",
"rubor",
"aguis",
"natja",
"zeles",
"impia",
"empin",
"timic",
"aboia",
"broca",
"fling",
"cloto",
"fusos",
"signo",
"etnic",
"basts",
"solaç",
"estor",
"difus",
"fulve",
"barxa",
"amoll",
"traca",
"danso",
"ornar",
"miops",
"runar",
"ducal",
"tiras",
"gases",
"verso",
"adire",
"peror",
"bufen",
"avale",
"betes",
"patri",
"atiam",
"ajova",
"aplan",
"oldre",
"mufen",
"buido",
"velat",
"tesat",
"adoll",
"sudet",
"conat",
"apart",
"casar",
"aturs",
"rapiu",
"glosi",
"testo",
"fixam",
"joier",
"prego",
"tests",
"hosts",
"tibes",
"fitem",
"astre",
"ansis",
"brand",
"indui",
"pente",
"melgo",
"dujam",
"largo",
"cerat",
"raseu",
"acubi",
"ponga",
"xupla",
"micos",
"verds",
"fotra",
"verns",
"sords",
"teati",
"arpas",
"arcas",
"maser",
"grato",
"sesam",
"dolin",
"pleba",
"esvar",
"vores",
"talla",
"tapas",
"valsi",
"taren",
"riura",
"agafo",
"xopeu",
"venit",
"libas",
"amans",
"retin",
"quids",
"aculo",
"trema",
"caral",
"hilar",
"mudeu",
"biont",
"faixe",
"dioic",
"bofia",
"menem",
"bitam",
"tmesi",
"gemat",
"plato",
"vanti",
"requi",
"xarro",
"apani",
"dorma",
"ansen",
"banda",
"jugue",
"patis",
"adeix",
"patia",
"veget",
"emeti",
"parer",
"ocell",
"moris",
"cofat",
"usant",
"forma",
"trufi",
"elape",
"bovor",
"rosts",
"bases",
"modis",
"pitgi",
"vauma",
"cervi",
"mengo",
"hadit",
"humer",
"vibro",
"pixeu",
"llave",
"folli",
"gravo",
"ajaeu",
"travo",
"totes",
"mitjo",
"terci",
"rosar",
"ibera",
"talas",
"dilat",
"papau",
"recav",
"seiem",
"conca",
"carca",
"pubia",
"vegeu",
"ratio",
"legio",
"duits",
"sueca",
"toscs",
"noien",
"clapo",
"somio",
"faces",
"ondem",
"afixo",
"nyecs",
"diacs",
"teids",
"viles",
"supos",
"tinyo",
"tapen",
"topes",
"terpe",
"suite",
"madur",
"rugim",
"calta",
"galiv",
"voran",
"niobi",
"arçar",
"jaiem",
"fovea",
"pujas",
"poper",
"heure",
"oxoni",
"lloca",
"falba",
"adori",
"incub",
"recto",
"ermar",
"xafec",
"extra",
"moare",
"manis",
"cosse",
"muram",
"gropa",
"paons",
"votiu",
"xollo",
"exeat",
"malms",
"bogue",
"noves",
"comen",
"aillo",
"afili",
"camio",
"afusa",
"gleva",
"parem",
"nanos",
"xaruc",
"xalin",
"besen",
"ninos",
"ocupa",
"eduia",
"xumau",
"atuia",
"ralla",
"lluça",
"picea",
"mites",
"grisu",
"cimam",
"poses",
"ritmo",
"novii",
"aurti",
"boies",
"togat",
"borem",
"mescl",
"aprop",
"xerre",
"papem",
"sulls",
"sexes",
"iodur",
"vitro",
"floca",
"atroç",
"melic",
"palpe",
"naveg",
"bisar",
"ofego",
"nedem",
"xarxa",
"sobta",
"piueu",
"calau",
"tract",
"traia",
"eixut",
"bleit",
"patir",
"esbes",
"dopar",
"ordiu",
"sarsa",
"arrop",
"alull",
"areno",
"janot",
"aucam",
"votau",
"vexem",
"trapa",
"egida",
"oliva",
"placo",
"sumia",
"tosos",
"tripo",
"defen",
"timal",
"zeros",
"acopa",
"frita",
"filem",
"sevir",
"ilota",
"ambul",
"obila",
"brota",
"xaiar",
"pansa",
"ronye",
"derma",
"munyo",
"aequo",
"pinar",
"esvor",
"insol",
"calcs",
"begut",
"plexe",
"alias",
"poeta",
"fuent",
"culls",
"modal",
"semen",
"hilid",
"cavas",
"xerec",
"sitia",
"capoc",
"purgo",
"capia",
"guimb",
"einam",
"nodus",
"tasts",
"bifer",
"sexis",
"vigim",
"minam",
"holmi",
"suare",
"fabul",
"monta",
"astut",
"gasen",
"ordir",
"ossut",
"didot",
"acule",
"agent",
"supli",
"puzle",
"ucare",
"fadis",
"regio",
"avina",
"bitol",
"cascu",
"sesto",
"setie",
"corea",
"arnie",
"brees",
"velas",
"nicol",
"garse",
"damne",
"ponta",
"paras",
"micet",
"actue",
"gitat",
"cente",
"pecam",
"robat",
"clami",
"tossa",
"gaido",
"doseu",
"arpau",
"tolus",
"ardit",
"garbi",
"timid",
"dutxi",
"esper",
"parot",
"solos",
"xulla",
"emane",
"fregi",
"param",
"dogma",
"fiava",
"culot",
"singl",
"aloer",
"falco",
"botau",
"boscs",
"zinco",
"urent",
"basar",
"lauan",
"vedam",
"septe",
"souet",
"teuli",
"creas",
"piteu",
"polsa",
"barda",
"ganut",
"halur",
"abece",
"atand",
"claro",
"salvs",
"burja",
"llins",
"cebar",
"marta",
"ampra",
"odios",
"fatic",
"estri",
"sonas",
"bolls",
"guipa",
"tallo",
"musca",
"xalam",
"numen",
"arids",
"bouet",
"oller",
"dolat",
"clone",
"canor",
"lluer",
"bolit",
"ports",
"mufem",
"erera",
"mioli",
"pians",
"clara",
"euros",
"quero",
"fusel",
"aliem",
"cadmi",
"elegi",
"filet",
"perve",
"visam",
"sides",
"xaiam",
"amote",
"iodau",
"haure",
"xapau",
"mapat",
"diput",
"apelf",
"vedar",
"cella",
"palpa",
"deixi",
"dades",
"cranc",
"brill",
"floxs",
"orant",
"enfon",
"pipau",
"volta",
"salle",
"reves",
"grops",
"envol",
"limit",
"macam",
"boniu",
"infos",
"eider",
"bonis",
"funyo",
"presa",
"dasia",
"defes",
"fiara",
"casat",
"parti",
"tapis",
"condi",
"sucar",
"enutj",
"risso",
"adida",
"expie",
"halin",
"sanis",
"safic",
"tatxi",
"codis",
"cobri",
"coman",
"oscul",
"rotes",
"assot",
"salep",
"nyafa",
"oloti",
"potra",
"poats",
"piral",
"deixa",
"brame",
"lucro",
"pobre",
"efors",
"untas",
"llarg",
"datis",
"lleeu",
"gabeu",
"orlis",
"atend",
"llega",
"retir",
"pagar",
"repeu",
"censo",
"pumes",
"fogau",
"fibla",
"xador",
"arpio",
"domam",
"feneu",
"torer",
"lloes",
"empit",
"quipa",
"nogui",
"guixa",
"arras",
"reten",
"malda",
"tarau",
"falte",
"botir",
"tixis",
"orden",
"sonso",
"espia",
"donar",
"dargo",
"theta",
"arner",
"laxem",
"mauri",
"onixs",
"orben",
"triau",
"llera",
"doner",
"parir",
"narri",
"mates",
"beina",
"votat",
"icacs",
"argil",
"tolts",
"facin",
"mafia",
"oliba",
"ofecs",
"nocau",
"secor",
"fremi",
"viura",
"vises",
"taiga",
"amort",
"noces",
"grums",
"morca",
"eximi",
"befau",
"riota",
"xacal",
"jacos",
"vigit",
"omple",
"clors",
"sogui",
"costi",
"grier",
"diner",
"anira",
"escol",
"balle",
"bover",
"pinxi",
"zenit",
"lacte",
"repas",
"aplec",
"sorts",
"pisat",
"rasem",
"ilium",
"forns",
"icona",
"ramal",
"epulo",
"rumin",
"dogam",
"clenx",
"firis",
"rasar",
"acalo",
"seien",
"guaix",
"raigs",
"colri",
"delco",
"adult",
"plasm",
"ordim",
"reisc",
"mocau",
"aguti",
"enfus",
"fenia",
"vagas",
"areca",
"burin",
"alens",
"sobri",
"tasco",
"reien",
"lobat",
"abata",
"litre",
"nabiu",
"torns",
"sirga",
"arpeu",
"avidi",
"tensi",
"aclof",
"pluja",
"oblia",
"carii",
"gardi",
"pipen",
"marin",
"calor",
"balli",
"agran",
"plomi",
"encim",
"claus",
"sigil",
"grata",
"enceg",
"sures",
"enols",
"sutza",
"podal",
"lacta",
"betic",
"femas",
"finia",
"torda",
"azina",
"fenol",
"rutil",
"terce",
"falda",
"manca",
"apunt",
"xufes",
"cessi",
"quant",
"xutem",
"mureu",
"tonen",
"setio",
"lladr",
"mixos",
"vacum",
"simun",
"pubic",
"corco",
"datau",
"xabia",
"acost",
"xiuli",
"brote",
"falso",
"cenyi",
"regla",
"signe",
"nadat",
"calis",
"bilio",
"nugam",
"tusso",
"boçat",
"milis",
"emmar",
"copas",
"pitis",
"gelem",
"surau",
"coits",
"incoo",
"plant",
"fesol",
"bilis",
"sedas",
"aglan",
"talma",
"boços",
"drapa",
"ataco",
"tafoi",
"digni",
"nugos",
"anega",
"sacio",
"musam",
"totil",
"nadam",
"abrog",
"riada",
"cervo",
"agrup",
"tevet",
"piler",
"hindi",
"coart",
"cimos",
"avanç",
"tanyi",
"della",
"urani",
"horst",
"culeu",
"rosto",
"urats",
"salia",
"menis",
"domeu",
"vello",
"gabau",
"tudat",
"hevea",
"tapon",
"lapsa",
"suara",
"biten",
"xumar",
"ginya",
"avini",
"sacas",
"llacs",
"pipat",
"salem",
"manxe",
"livid",
"resat",
"ciati",
"cabro",
"ralli",
"lligo",
"trufa",
"viant",
"jugal",
"basis",
"verpa",
"plaem",
"endol",
"fogui",
"alots",
"jutge",
"recer",
"apone",
"xaira",
"xeixa",
"reixa",
"enduc",
"esmol",
"motiv",
"opali",
"fetjo",
"erigi",
"vetau",
"bufec",
"tinti",
"teves",
"plaia",
"diuen",
"urgia",
"triin",
"ginyi",
"hagin",
"bebes",
"calda",
"plaeu",
"sigla",
"filtr",
"trets",
"vasco",
"calco",
"canoa",
"veres",
"mimic",
"burla",
"encop",
"viler",
"llogo",
"mafic",
"falla",
"refus",
"frija",
"aboco",
"puber",
"gamen",
"cofes",
"arruo",
"bufis",
"domte",
"fosfe",
"fusts",
"cuino",
"salvo",
"pipiu",
"gemes",
"opteu",
"estel",
"bisbe",
"habit",
"cuito",
"espie",
"untos",
"dropa",
"roste",
"lacri",
"avili",
"besem",
"parlo",
"sobra",
"aviso",
"neven",
"jubil",
"suecs",
"gamas",
"pelen",
"moros",
"dutxo",
"laics",
"imada",
"setia",
"innov",
"ronxa",
"viats",
"jonis",
"debat",
"fadas",
"faixo",
"amaro",
"neulo",
"gorja",
"alçam",
"xutau",
"anime",
"flaix",
"paves",
"solin",
"hopes",
"adagi",
"cucas",
"cracs",
"vagen",
"mugis",
"trefi",
"traem",
"cubic",
"apuig",
"xalma",
"cerno",
"verga",
"lleim",
"mirau",
"abone",
"lloen",
"etils",
"havia",
"pedra",
"rapat",
"romer",
"anava",
"gasiu",
"orare",
"bullo",
"ornes",
"morfs",
"garlo",
"virus",
"curie",
"bells",
"ajupa",
"cians",
"iaies",
"bitoc",
"furau",
"canem",
"cremo",
"xinis",
"taxar",
"unies",
"lleva",
"alaui",
"burge",
"cimes",
"tetes",
"crana",
"cules",
"afers",
"ceria",
"gatet",
"saura",
"sufix",
"ratau",
"femau",
"palat",
"criin",
"llepe",
"pires",
"ainem",
"tupes",
"eduis",
"apuro",
"tatuo",
"timbr",
"oliat",
"tabus",
"fucus",
"grani",
"zonal",
"capti",
"amics",
"blats",
"rafet",
"olent",
"binin",
"amago",
"pisin",
"xaier",
"ardua",
"nefro",
"senta",
"sedal",
"ivons",
"xuplo",
"ordii",
"orege",
"tarja",
"corno",
"canar",
"rulli",
"caqui",
"guixi",
"halem",
"cofar",
"trota",
"feien",
"talle",
"femar",
"rotis",
"rasts",
"balde",
"musat",
"escuc",
"buidi",
"bondo",
"potto",
"vista",
"iodas",
"plens",
"trago",
"fideu",
"tatua",
"salpa",
"acaba",
"clama",
"vasta",
"tacat",
"ujada",
"creue",
"celas",
"canes",
"junyo",
"niala",
"oscil",
"pinya",
"morim",
"mansa",
"mesam",
"sipai",
"lluca",
"turos",
"copin",
"canos",
"dotem",
"anecs",
"coten",
"capeu",
"xamor",
"espos",
"anyol",
"blaur",
"teler",
"peona",
"amain",
"acobl",
"esmic",
"terri",
"dotau",
"envas",
"robeu",
"baseu",
"cisen",
"ruans",
"girin",
"bolcs",
"amidi",
"fonen",
"eixon",
"atupi",
"pagui",
"catxo",
"guait",
"jaieu",
"vente",
"boras",
"somat",
"empot",
"urgir",
"uigur",
"plati",
"curin",
"cense",
"illot",
"trems",
"bitat",
"camut",
"feder",
"galda",
"bajoc",
"lacis",
"besau",
"polix",
"preue",
"rapas",
"seves",
"boers",
"bugat",
"baciu",
"focea",
"gaial",
"piren",
"viari",
"quils",
"actuo",
"raent",
"viare",
"agams",
"sorra",
"pesen",
"acota",
"pince",
"nyapa",
"guipi",
"obeiu",
"couri",
"epice",
"urees",
"situe",
"deixe",
"preas",
"atuiu",
"sodes",
"gremi",
"ureid",
"visis",
"forgi",
"cabes",
"tusts",
"momes",
"celen",
"volat",
"peneu",
"trame",
"ocres",
"darem",
"beset",
"befat",
"empeg",
"abuso",
"vidre",
"colli",
"afini",
"temps",
"giram",
"tupen",
"moixa",
"agrai",
"lacer",
"cablo",
"ditas",
"xocas",
"luxen",
"alarm",
"deriv",
"rebis",
"lemes",
"harem",
"atris",
"nugat",
"duges",
"gotos",
"circa",
"mamei",
"tinye",
"varat",
"codex",
"afana",
"tesar",
"frena",
"afori",
"poise",
"oferi",
"mossa",
"maçol",
"cimis",
"visin",
"silur",
"orinc",
"endur",
"brios",
"humil",
"eixea",
"lenta",
"creta",
"infli",
"agreg",
"apago",
"ponto",
"xueta",
"gofri",
"bamba",
"estof",
"tacam",
"maçam",
"gaspi",
"ceric",
"moren",
"lloba",
"negam",
"quica",
"isolo",
"mesos",
"aculi",
"metia",
"regis",
"renta",
"gemin",
"atuix",
"mares",
"manam",
"oimes",
"ramen",
"obren",
"daina",
"ujats",
"cinte",
"freso",
"boiet",
"ajaci",
"arnii",
"creps",
"gameu",
"gotes",
"nanes",
"tesas",
"amero",
"dates",
"guals",
"media",
"gauge",
"bivac",
"manta",
"ermos",
"orbam",
"sedec",
"ordix",
"bravo",
"tamin",
"afina",
"solen",
"xurmi",
"aleja",
"trocs",
"ludes",
"label",
"pigra",
"ficus",
"avare",
"cuses",
"minor",
"blega",
"papas",
"lleig",
"vigir",
"atret",
"hagis",
"galzi",
"agarb",
"maula",
"nadis",
"aplac",
"irise",
"mullo",
"fluir",
"eixim",
"fatus",
"nonet",
"ureta",
"iodin",
"telis",
"caduf",
"farga",
"xusma",
"rufol",
"rojor",
"vetes",
"pagam",
"colom",
"sexat",
"femis",
"adiau",
"aigua",
"mofen",
"nocas",
"pelec",
"nasca",
"crieu",
"argiu",
"somni",
"cruor",
"moret",
"rosos",
"queim",
"meler",
"caria",
"cudus",
"tinte",
"memor",
"llast",
"pesos",
"croat",
"feram",
"faust",
"piuli",
"taxam",
"bordi",
"feixi",
"mitra",
"gruar",
"siuli",
"renal",
"llocs",
"urpir",
"amare",
"pegot",
"friso",
"opcio",
"alerç",
"justs",
"molam",
"ansem",
"angle",
"melva",
"lanid",
"teixo",
"xamos",
"brufo",
"follo",
"potos",
"apter",
"darda",
"copie",
"viseu",
"deixo",
"jutja",
"hesit",
"exhal",
"civic",
"alcis",
"peque",
"raieu",
"verbs",
"itera",
"baixi",
"vanto",
"senis",
"oiare",
"rulot",
"catxe",
"treso",
"topen",
"migre",
"viona",
"anire",
"conus",
"ranci",
"sucas",
"vetos",
"befis",
"tasso",
"agriu",
"ngais",
"rivet",
"acapt",
"fixen",
"picid",
"noura",
"otoma",
"napis",
"zeleu",
"carte",
"deten",
"laxen",
"mapar",
"aliat",
"fonia",
"druts",
"quall",
"vibre",
"bisin",
"retxo",
"atorg",
"befam",
"minim",
"teulo",
"vanat",
"raier",
"senat",
"palle",
"argot",
"viver",
"atrac",
"copam",
"icosa",
"pitof",
"ufans",
"tudes",
"linxo",
"lleia",
"menen",
"capce",
"botit",
"ompli",
"acmes",
"blaso",
"marre",
"nurag",
"capto",
"calms",
"rearm",
"xapin",
"agios",
"befen",
"algia",
"tapir",
"ricam",
"capot",
"pense",
"errin",
"vedes",
"occim",
"hegui",
"cedix",
"acuit",
"timba",
"urpis",
"ebria",
"conga",
"curam",
"pesem",
"beren",
"pared",
"tudem",
"sucat",
"avets",
"celat",
"brous",
"ragis",
"oriol",
"nimbo",
"furam",
"bombi",
"neixi",
"vedem",
"rotar",
"freus",
"ferma",
"papio",
"cotau",
"uveal",
"aviat",
"libis",
"arros",
"amuri",
"becut",
"samis",
"liber",
"agras",
"xifla",
"arils",
"maria",
"bruga",
"caceu",
"luxas",
"greix",
"trini",
"penco",
"fotis",
"taxes",
"bonze",
"esses",
"necis",
"moble",
"grifo",
"teris",
"facil",
"sobre",
"tirar",
"tapie",
"grans",
"tasta",
"benes",
"morir",
"saros",
"gasau",
"junya",
"mauix",
"cruis",
"jueva",
"conxa",
"bessa",
"opiat",
"lleud",
"grana",
"inoit",
"befin",
"pixel",
"furot",
"durar",
"ramat",
"xurma",
"nomen",
"palmo",
"sipat",
"mutus",
"fibli",
"xuixo",
"palet",
"bolei",
"hepta",
"ululi",
"sotge",
"llaço",
"mapeu",
"fatxa",
"corsa",
"rigid",
"repic",
"cruix",
"seuos",
"fiant",
"sacat",
"viaro",
"onses",
"apres",
"frens",
"derbi",
"enyes",
"sedam",
"auris",
"malvi",
"flirt",
"pegat",
"feies",
"duent",
"rauti",
"berma",
"tacas",
"locio",
"acula",
"boien",
"arrei",
"lloat",
"guiau",
"dubte",
"mugim",
"ragin",
"narra",
"capça",
"pipar",
"nuava",
"giten",
"coixi",
"orlau",
"aponi",
"fetus",
"palai",
"xitar",
"bigos",
"dormo",
"calid",
"optam",
"torni",
"engas",
"renye",
"cerne",
"xapen",
"ambit",
"jussa",
"triba",
"clamp",
"munti",
"bitar",
"belar",
"gojos",
"acere",
"miola",
"feliç",
"arego",
"avido",
"datat",
"bavor",
"mango",
"rupit",
"marra",
"reals",
"ailli",
"fluim",
"cresc",
"lleis",
"ungit",
"formi",
"voria",
"texts",
"untis",
"guisa",
"acaci",
"versa",
"viure",
"lleny",
"meres",
"closc",
"nexes",
"fleca",
"allos",
"solas",
"iodam",
"amors",
"vinga",
"duria",
"valis",
"boieu",
"pitic",
"agafi",
"popas",
"novel",
"ujara",
"ulles",
"crisp",
"cobre",
"avari",
"xapas",
"olias",
"remam",
"bruel",
"pirau",
"burra",
"petgi",
"bonia",
"resem",
"bruit",
"meros",
"llosc",
"games",
"optic",
"folic",
"cruia",
"cuita",
"boxat",
"obreu",
"cedri",
"fingi",
"pista",
"deuen",
"etapa",
"atols",
"mimat",
"oxido",
"obeix",
"hagiu",
"bagot",
"gofre",
"dials",
"ajust",
"turac",
"velam",
"antec",
"enfav",
"obric",
"voreu",
"argus",
"pisam",
"alçat",
"taque",
"cotni",
"deton",
"adiam",
"ullas",
"glots",
"favar",
"penol",
"brams",
"geles",
"aldea",
"rauca",
"suras",
"sodar",
"tigre",
"unari",
"perfe",
"regam",
"arams",
"domar",
"panxa",
"porte",
"votar",
"foehn",
"abeur",
"melia",
"sedem",
"toque",
"dindi",
"sonat",
"botja",
"bogat",
"docta",
"cuque",
"rifas",
"afait",
"ptosi",
"imiti",
"omesa",
"dinou",
"ruera",
"telau",
"telem",
"crica",
"regim",
"poseu",
"feraç",
"gaire",
"senia",
"oiras",
"borde",
"sermo",
"mioma",
"soles",
"aucat",
"meues",
"dicli",
"falti",
"tisic",
"robot",
"redol",
"boças",
"robin",
"cotat",
"daras",
"bucar",
"muira",
"pelag",
"endos",
"incou",
"tolis",
"occia",
"reuni",
"dites",
"anara",
"ronxo",
"marxo",
"itere",
"balbe",
"pausa",
"rento",
"apose",
"torno",
"coets",
"sumir",
"fumen",
"gitis",
"fenen",
"oscos",
"ratxo",
"mufat",
"xerri",
"cavem",
"venos",
"bromo",
"depes",
"avern",
"suors",
"usare",
"solca",
"senti",
"taleu",
"ensab",
"ollal",
"cofeu",
"aglev",
"serem",
"beata",
"ronyi",
"trust",
"rodal",
"dopas",
"tombo",
"drapo",
"borat",
"solit",
"lobar",
"nacte",
"hades",
"odies",
"quedi",
"coder",
"onegi",
"ensot",
"fogam",
"parla",
"aplom",
"acuse",
"xarot",
"gomet",
"gambo",
"bioma",
"punxa",
"fores",
"gosau",
"aflui",
"miler",
"xafeu",
"hissi",
"xarre",
"arcam",
"baies",
"bades",
"tomis",
"celis",
"emete",
"malar",
"inhum",
"tebis",
"tomas",
"xopem",
"palpo",
"tipis",
"xiita",
"noies",
"setis",
"ofset",
"escur",
"parca",
"forad",
"malta",
"apila",
"dilui",
"borna",
"tiren",
"debil",
"aquos",
"bolig",
"itris",
"banal",
"alces",
"caler",
"atiis",
"vanau",
"lobel",
"sones",
"recit",
"xocam",
"timol",
"feris",
"hagem",
"zombi",
"lisis",
"atiem",
"avesi",
"abriv",
"bojor",
"repix",
"vacus",
"gadid",
"bulbs",
"sogat",
"solti",
"velit",
"refie",
"judes",
"hageu",
"cuine",
"fibra",
"dolis",
"doble",
"tanyo",
"fonau",
"opose",
"gelos",
"bocat",
"tetan",
"resar",
"urubu",
"llurs",
"ertic",
"poble",
"semos",
"dugeu",
"pales",
"xaque",
"nitri",
"caoli",
"aspra",
"anyer",
"orbar",
"penar",
"satur",
"coval",
"gepic",
"xifri",
"menut",
"sucre",
"vamba",
"xaloc",
"gleba",
"covis",
"maure",
"ainus",
"magne",
"bolca",
"crein",
"difon",
"caldo",
"boqui",
"mirba",
"renos",
"redir",
"bufar",
"ordis",
"desoi",
"hassi",
"cunys",
"tutsi",
"avenc",
"adobs",
"obria",
"femer",
"apoma",
"rifes",
"xalis",
"halit",
"cream",
"mucro",
"topis",
"violo",
"aquis",
"bidet",
"delis",
"toses",
"alcea",
"proer",
"banye",
"tancs",
"rodau",
"topic",
"ajaus",
"topam",
"vesta",
"zinca",
"firam",
"meixa",
"metel",
"preve",
"ruixa",
"parsi",
"pagau",
"enriu",
"plome",
"parta",
"ujant",
"corri",
"toies",
"asmat",
"bordo",
"ardus",
"arnin",
"aseta",
"pedio",
"becau",
"dosin",
"crism",
"entro",
"medit",
"enrun",
"laxis",
"ermis",
"samer",
"airar",
"vedas",
"adiny",
"molga",
"ucats",
"front",
"ivori",
"fonya",
"petal",
"cavet",
"haleu",
"tabal",
"xorra",
"apega",
"operi",
"visur",
"garol",
"carmi",
"depur",
"dinya",
"murem",
"vesin",
"arpin",
"plany",
"grial",
"guise",
"mitil",
"marda",
"eunuc",
"tacar",
"velau",
"queis",
"erola",
"gesto",
"sueus",
"denti",
"judos",
"linxa",
"minie",
"arqui",
"azole",
"taxem",
"torce",
"viram",
"podar",
"brell",
"major",
"bitem",
"vante",
"ugons",
"fatal",
"cremi",
"arcar",
"music",
"empop",
"nades",
"afami",
"ramar",
"falls",
"cebid",
"abraç",
"renys",
"boiga",
"arlot",
"sogam",
"llars",
"vomit",
"vorem",
"badam",
"feroç",
"andes",
"adulo",
"soria",
"midau",
"sobro",
"locus",
"visen",
"bonys",
"paura",
"fonda",
"optat",
"obten",
"bufor",
"remou",
"burro",
"mides",
"remol",
"puden",
"veien",
"xopau",
"obvis",
"creus",
"pompa",
"mures",
"buits",
"finir",
"conic",
"nadem",
"fianç",
"arpar",
"exsol",
"xafic",
"teues",
"adnat",
"pinyo",
"morta",
"cabia",
"lloeu",
"lloms",
"afame",
"aposi",
"xalet",
"cordo",
"enart",
"carri",
"ogres",
"sanes",
"rallo",
"modul",
"unixo",
"ortic",
"saigs",
"rifam",
"melsa",
"amorf",
"obste",
"somic",
"enduu",
"acunç",
"armer",
"armas",
"optas",
"laque",
"ulans",
"ascos",
"zelen",
"domem",
"manau",
"xotxo",
"colgo",
"bords",
"podat",
"xuclo",
"fimbr",
"mofau",
"citem",
"laves",
"prisa",
"denud",
"sufle",
"socam",
"parcs",
"jaços",
"festa",
"halos",
"racio",
"minii",
"afust",
"veden",
"botra",
"sensu",
"sores",
"necia",
"acluc",
"casam",
"furen",
"aligo",
"baven",
"intub",
"panda",
"boren",
"botix",
"metre",
"afueu",
"salis",
"dinas",
"tiram",
"fadau",
"nepta",
"cuits",
"obols",
"matxs",
"coles",
"ullal",
"galgo",
"dolia",
"rodes",
"jeien",
"pares",
"rafis",
"calme",
"drece",
"tatxo",
"punte",
"lirat",
"roine",
"amiga",
"guapa",
"seieu",
"vagim",
"torci",
"valso",
"nitra",
"armam",
"carga",
"creix",
"cosia",
"aiori",
"equid",
"arsis",
"erogo",
"moure",
"sabre",
"codol",
"mutua",
"deces",
"penos",
"calar",
"ireix",
"calos",
"xinem",
"trese",
"segut",
"rebel",
"roals",
"miden",
"seder",
"balbs",
"anims",
"arila",
"punya",
"paera",
"cular",
"bauds",
"oliar",
"menys",
"redos",
"bufin",
"colit",
"evadi",
"tints",
"junta",
"atraç",
"saldi",
"pipem",
"falçs",
"sipis",
"fixos",
"tesor",
"diada",
"retro",
"fulgi",
"odori",
"fasts",
"visas",
"foreu",
"venet",
"nevam",
"alaba",
"saleu",
"rebeu",
"divag",
"opals",
"ciseu",
"rotor",
"eluim",
"calfo",
"xauxa",
"garfi",
"cerut",
"llobi",
"sumem",
"amele",
"gamis",
"areng",
"sopor",
"grava",
"caden",
"treis",
"amelo",
"torbo",
"rageu",
"raure",
"vitxo",
"poliu",
"situa",
"airin",
"botes",
"copte",
"batra",
"alana",
"metem",
"cobra",
"finti",
"pocio",
"ramin",
"afino",
"ennov",
"curar",
"empre",
"adver",
"blues",
"prega",
"astat",
"emule",
"suids",
"emmen",
"bises",
"brusc",
"covam",
"isoli",
"reglo",
"desar",
"adjur",
"copra",
"arsia",
"guiem",
"espot",
"tresc",
"cabem",
"avinc",
"abdui",
"avise",
"ester",
"odres",
"minar",
"malva",
"punxe",
"mamen",
"curau",
"netes",
"ludic",
"pileu",
"brotx",
"papal",
"aliis",
"voten",
"punta",
"baris",
"index",
"gelea",
"donau",
"atros",
"suats",
"fiare",
"trace",
"coala",
"punit",
"odrer",
"ligni",
"circs",
"ocorr",
"joana",
"troti",
"solis",
"moles",
"pasts",
"cases",
"bogam",
"boçau",
"gabia",
"mitja",
"sacre",
"cafta",
"justi",
"nadar",
"jaura",
"carex",
"crics",
"botri",
"errau",
"parix",
"litic",
"podin",
"obtur",
"ignor",
"balmi",
"filio",
"tardo",
"treus",
"tedis",
"rimam",
"sards",
"praxi",
"trunc",
"pigos",
"taule",
"druda",
"dides",
"pifre",
"fonts",
"aveso",
"bisis",
"excav",
"magna",
"cadec",
"bolid",
"fosfa",
"remau",
"zetes",
"bocen",
"brocs",
"acers",
"tassa",
"finar",
"capet",
"aspii",
"galet",
"entur",
"avena",
"satiu",
"redox",
"meats",
"rauto",
"ornin",
"liben",
"vaneu",
"sarro",
"aeria",
"xamat",
"calds",
"roses",
"duets",
"recas",
"manxa",
"fixes",
"deies",
"laqui",
"jugar",
"uteri",
"fluiu",
"mogue",
"dolas",
"viris",
"cavin",
"rasos",
"envel",
"grimp",
"andan",
"debel",
"faisa",
"botis",
"xiteu",
"crani",
"senyo",
"jaupo",
"faune",
"salze",
"ambli",
"erros",
"gojas",
"dolça",
"ruble",
"tibar",
"llago",
"areny",
"assec",
"negar",
"copse",
"halis",
"prive",
"enrai",
"llims",
"munys",
"pogue",
"donat",
"maçon",
"galio",
"macar",
"blima",
"irona",
"prues",
"sipio",
"jagui",
"illes",
"bonda",
"jardi",
"atzur",
"pinte",
"titis",
"rapto",
"tissu",
"tulis",
"prons",
"desol",
"irosa",
"venim",
"xitam",
"exalç",
"cedir",
"acant",
"nuvis",
"optim",
"elenc",
"refes",
"hulla",
"faena",
"eroli",
"tupat",
"acima",
"adeim",
"limfa",
"enton",
"afusi",
"lotic",
"pinta",
"raors",
"ditet",
"tatar",
"glies",
"emano",
"oeixi",
"admir",
"nogat",
"anoti",
"tenar",
"gelor",
"incoi",
"xumis",
"patim",
"boxin",
"coopt",
"natgi",
"ciclo",
"segon",
"oires",
"pleca",
"iogui",
"celar",
"ensum",
"forjo",
"veies",
"fages",
"picol",
"xunts",
"vanin",
"riera",
"regir",
"porti",
"casta",
"verat",
"rosam",
"curos",
"badem",
"avias",
"prois",
"xaieu",
"foner",
"sisme",
"tarif",
"eflui",
"conto",
"arruu",
"acana",
"teixi",
"pouam",
"orfic",
"oxids",
"queix",
"peles",
"dumes",
"lauda",
"varie",
"setes",
"tribu",
"minsa",
"pixum",
"foceu",
"perxo",
"renou",
"sacia",
"colle",
"nolit",
"domer",
"quilo",
"lassi",
"cacin",
"carli",
"acars",
"viril",
"roser",
"ereta",
"rombe",
"tuies",
"rebin",
"ungix",
"safir",
"filum",
"bohri",
"bavis",
"nedin",
"lando",
"envii",
"sacos",
"tudeu",
"afixa",
"trill",
"eines",
"albio",
"petas",
"tocom",
"alfes",
"clofa",
"mudes",
"egees",
"venem",
"jaupi",
"avive",
"llaus",
"petau",
"nuada",
"maimo",
"xates",
"seden",
"aglos",
"cofem",
"bavin",
"rafio",
"tapia",
"coble",
"fofos",
"pifol",
"polso",
"bagas",
"pisar",
"cuegi",
"penjo",
"amblo",
"varva",
"arcat",
"aprad",
"fusio",
"blana",
"lliti",
"caure",
"servo",
"unieu",
"india",
"sango",
"rapim",
"frisi",
"eluir",
"alums",
"lasso",
"forci",
"dador",
"tauts",
"acopi",
"alabe",
"fliti",
"balms",
"pixem",
"cofin",
"neule",
"acaço",
"ictus",
"fissa",
"dolem",
"emana",
"facis",
"corrs",
"preny",
"cuide",
"dopeu",
"naies",
"violi",
"estac",
"becas",
"ligur",
"refii",
"fonar",
"impur",
"resam",
"varii",
"capix",
"xineu",
"hispa",
"vesti",
"nuant",
"lluit",
"anaps",
"palla",
"llois",
"hafni",
"gotic",
"dards",
"xopas",
"comem",
"cista",
"femto",
"nyics",
"sesta",
"ocapi",
"encau",
"oeixo",
"canti",
"telam",
"roino",
"borle",
"punto",
"sicul",
"corra",
"sopes",
"serps",
"beseu",
"folro",
"calin",
"ideis",
"vanes",
"crepe",
"agnat",
"sopis",
"gasco",
"aires",
"gicat",
"llusc",
"torça",
"molar",
"remeu",
"besso",
"nyams",
"coixa",
"drens",
"decap",
"mateu",
"penen",
"tupas",
"menga",
"urnes",
"mufla",
"xafau",
"arbre",
"isola",
"abono",
"guell",
"sents",
"botil",
"ebens",
"cofam",
"mollo",
"venço",
"boids",
"acotx",
"veieu",
"ossat",
"culer",
"reben",
"punis",
"empou",
"incit",
"maixe",
"densa",
"apoco",
"raten",
"xumas",
"xalat",
"dunes",
"arnat",
"banat",
"carst",
"iambe",
"maneu",
"ficat",
"verin",
"cimal",
"toneu",
"andar",
"guixe",
"fuita",
"camal",
"peçol",
"gerds",
"siboc",
"garle",
"baldi",
"ritmi",
"escon",
"flita",
"sirte",
"funys",
"fendi",
"enjus",
"comin",
"tosca",
"arnis",
"xapeu",
"plaga",
"polia",
"dutes",
"padda",
"adore",
"aviin",
"bogar",
"mucor",
"rafec",
"simis",
"torne",
"bolet",
"colic",
"vespa",
"astis",
"pirin",
"renga",
"borax",
"afoga",
"aguat",
"dutxe",
"gojau",
"murau",
"rebia",
"nanno",
"foneu",
"mieta",
"signi",
"educa",
"miser",
"abast",
"gijol",
"divos",
"clars",
"hepte",
"armem",
"emesa",
"dacio",
"bills",
"amnic",
"ossam",
"bromi",
"pobla",
"funya",
"boics",
"segui",
"sabeu",
"gaons",
"panxo",
"trufo",
"ungli",
"ganya",
"volea",
"veteu",
"munim",
"apuja",
"golls",
"gabat",
"aport",
"ungir",
"juris",
"vocal",
"acani",
"ulema",
"amecs",
"tupam",
"ornat",
"vagal",
"paixi",
"lucis",
"crema",
"trone",
"hotel",
"neula",
"avine",
"cavat",
"minut",
"faden",
"domen",
"nevat",
"aboin",
"xufla",
"ertes",
"infle",
"valga",
"sonda",
"ermin",
"rifis",
"boxen",
"feres",
"buide",
"napel",
"vereu",
"grups",
"munta",
"treia",
"broms",
"obven",
"tumul",
"regne",
"hilum",
"macer",
"aposa",
"piran",
"gorra",
"remot",
"cusis",
"borra",
"raiem",
"sarpa",
"tupin",
"notau",
"arili",
"edril",
"floto",
"miras",
"doleu",
"gepes",
"veros",
"atipi",
"auric",
"maten",
"paixe",
"teseu",
"balit",
"osses",
"dotis",
"atard",
"bipla",
"bufat",
"reput",
"mufas",
"obtin",
"veina",
"polos",
"solut",
"honri",
"arrio",
"altos",
"angla",
"posen",
"faran",
"dandi",
"mogui",
"amida",
"pulmo",
"buida",
"conti",
"ullet",
"xafam",
"naixo",
"agave",
"jocos",
"badat",
"eteri",
"cauta",
"viras",
"calat",
"cisis",
"mulle",
"belin",
"furte",
"fetes",
"serii",
"fundi",
"celem",
"edito",
"rompi",
"colat",
"airam",
"babol",
"afuat",
"macas",
"ferms",
"rompa",
"veraç",
"temer",
"favor",
"clova",
"aguts",
"venge",
"fitxi",
"semem",
"tirau",
"agram",
"remig",
"bunes",
"niava",
"obert",
"arnar",
"delmi",
"dujas",
"munis",
"fusat",
"minis",
"pipas",
"muixa",
"jeies",
"cucam",
"citas",
"pegam",
"piuis",
"remer",
"tonga",
"alefs",
"ricau",
"peone",
"ratxi",
"avien",
"mores",
"aulic",
"dosam",
"panes",
"venda",
"jacte",
"ossia",
"esmas",
"pipes",
"sames",
"fugin",
"febre",
"gusts",
"atrec",
"ruste",
"pouem",
"metja",
"molen",
"siulo",
"rebem",
"estem",
"ulcer",
"estir",
"pinci",
"paien",
"avior",
"heroi",
"gotxa",
"tremo",
"veren",
"xolle",
"preen",
"teses",
"pugis",
"llace",
"plaço",
"grane",
"tupis",
"mixes",
"sorgo",
"tonus",
"refin",
"fitin",
"ebris",
"hiena",
"vento",
"tanys",
"ritme",
"tempr",
"dosat",
"minem",
"acuts",
"agris",
"cacem",
"evito",
"bones",
"nugau",
"pegau",
"grifs",
"gesps",
"unics",
"vigix",
"exalt",
"pesol",
"aidis",
"unire",
"risse",
"loqui",
"cleta",
"embeu",
"cabus",
"nevau",
"dotar",
"solla",
"esten",
"porxo",
"velar",
"basti",
"coiem",
"mesat",
"tempo",
"empil",
"octet",
"tapii",
"occix",
"hutus",
"lidis",
"finix",
"dubti",
"fluor",
"parim",
"lames",
"musar",
"oolit",
"fraga",
"motxa",
"tremp",
"sonic",
"gallo",
"gaudi",
"sesti",
"colza",
"brogi",
"sedat",
"visor",
"lamia",
"pesis",
"didos",
"nafra",
"tecis",
"sedui",
"repta",
"acane",
"xofer",
"faula",
"citat",
"filat",
"batle",
"pelai",
"agues",
"afuar",
"oleic",
"vital",
"cague",
"auque",
"basas",
"mamar",
"fadar",
"dujat",
"rugia",
"sidra",
"rajol",
"atles",
"polli",
"pagas",
"radis",
"cruie",
"aguas",
"clops",
"asson",
"aspat",
"bruts",
"amara",
"inris",
"ostra",
"muler",
"porca",
"eriço",
"dinyi",
"pupil",
"conxe",
"bogos",
"oixes",
"vairo",
"apost",
"trinc",
"llaun",
"asils",
"oests",
"cabli",
"pudol",
"forme",
"equip",
"clavo",
"manen",
"museu",
"sumas",
"enuig",
"sobti",
"gleis",
"afons",
"delix",
"musis",
"remir",
"colet",
"fajol",
"reblo",
"rapen",
"passo",
"glaci",
"exigu",
"flits",
"trios",
"trull",
"pinna",
"gogin",
"raspe",
"beaba",
"hadro",
"dalli",
"almon",
"bites",
"plega",
"alifs",
"reies",
"cebes",
"xoriç",
"evite",
"renet",
"tacte",
"fetal",
"perit",
"usada",
"duode",
"carpi",
"coapt",
"jurau",
"paona",
"adhuc",
"cuidi",
"feriu",
"arnio",
"rodia",
"mural",
"nyaco",
"penam",
"esmes",
"notes",
"ofenc",
"nucli",
"brivi",
"buina",
"pixen",
"iliac",
"siule",
"traça",
"cintr",
"esnob",
"sutge",
"falca",
"botxi",
"roent",
"ainar",
"opino",
"gelar",
"nipis",
"dopem",
"apall",
"tarot",
"artic",
"deure",
"repte",
"vomic",
"cessa",
"isqui",
"papat",
"capam",
"rugbi",
"cople",
"epode",
"jugui",
"negas",
"afogo",
"guipe",
"cairi",
"sodat",
"agror",
"tomau",
"dreno",
"tires",
"donja",
"crebi",
"marea",
"monos",
"femat",
"vogia",
"optis",
"ideeu",
"ranca",
"pesas",
"daric",
"copel",
"atieu",
"murat",
"falta",
"zulus",
"force",
"expen",
"badiu",
"pisca",
"ideam",
"curts",
"forbi",
"grius",
"bruna",
"bloca",
"preus",
"bisat",
"masia",
"afeli",
"tusti",
"menam",
"forca",
"pinto",
"fosso",
"bufeu",
"conxo",
"abusa",
"xapot",
"fonyi",
"boves",
"usara",
"marcs",
"orfes",
"vogar",
"pisen",
"fogar",
"perim",
"tanda",
"xolli",
"cosim",
"borns",
"gicau",
"talls",
"nitre",
"curta",
"xueto",
"blecs",
"oient",
"alegr",
"alcen",
"pures",
"fineu",
"cogue",
"males",
"eriça",
"aster",
"atipa",
"fasos",
"flota",
"paret",
"resol",
"atoni",
"flacs",
"al·le",
"delma",
"llufi",
"salat",
"busso",
"leses",
"xorri",
"larix",
"fonam",
"apama",
"xiulo",
"temut",
"natro",
"andoi",
"veire",
"alber",
"beuen",
"furer",
"nonat",
"boire",
"lores",
"retur",
"vanen",
"aljub",
"jurar",
"voral",
"tolta",
"trast",
"pouas",
"porat",
"desos",
"plans",
"adesi",
"urics",
"armin",
"dejus",
"dalin",
"tixen",
"vogui",
"cerro",
"oiren",
"llaor",
"vodus",
"covat",
"soler",
"supur",
"olien",
"fenix",
"gomer",
"cupes",
"brufe",
"reviu",
"venta",
"rufes",
"fenas",
"vario",
"cegar",
"filau",
"surts",
"senya",
"estaf",
"llors",
"dubni",
"topin",
"avere",
"amoli",
"hisse",
"quiet",
"oocit",
"tesam",
"natjo",
"ionis",
"llaci",
"lilas",
"alosa",
"aquea",
"traut",
"caros",
"afric",
"arpon",
"viole",
"tapes",
"postr",
"tutis",
"tofut",
"liqua",
"cogit",
"flixa",
"etiol",
"bocut",
"gresa",
"magol",
"roden",
"avera",
"envit",
"vacat",
"alcin",
"bales",
"aduli",
"moblo",
"pitja",
"nadau",
"reina",
"secta",
"nomis",
"xotro",
"cloro",
"sitid",
"naifs",
"maqui",
"jurat",
"haplo",
"firem",
"vareu",
"remei",
"gruis",
"salli",
"auixo",
"parli",
"vogit",
"nedar",
"xamas",
"apili",
"esser",
"olbia",
"ideas",
"agraf",
"errar",
"bateg",
"daren",
"birbi",
"egues",
"xibec",
"boxas",
"vagau",
"cuqui",
"gorga",
"orixs",
"botut",
"cobai",
"bucci",
"tesin",
"duien",
"gosam",
"tinyi",
"aurts",
"duana",
"xaman",
"nials",
"acull",
"feixo",
"amunt",
"porgo",
"brego",
"cosir",
"apitr",
"clasc",
"versi",
"clecs",
"unena",
"nenia",
"vells",
"calço",
"guiar",
"espui",
"palau",
"belam",
"xitis",
"gasis",
"moque",
"brufi",
"cedis",
"naden",
"lacau",
"ioles",
"xaiat",
"vacam",
"cauts",
"joios",
"avols",
"ganso",
"orria",
"mobil",
"filie",
"aidar",
"altar",
"flixo",
"horts",
"grate",
"coves",
"cromi",
"resti",
"baixe",
"retoc",
"criam",
"menjo",
"pomer",
"estic",
"adira",
"llufo",
"femeu",
"sotjo",
"digno",
"pasti",
"mutic",
"cossa",
"sales",
"galib",
"vomer",
"fitxa",
"banca",
"curen",
"voris",
"murin",
"falua",
"sexem",
"mouen",
"voste",
"somie",
"danys",
"xanxa",
"regue",
"drusa",
"rebes",
"forts",
"pubis",
"morsa",
"mingo",
"badar",
"visir",
"essiu",
"paten",
"perxi",
"advin",
"mocam",
"brans",
"fitor",
"corne",
"cardi",
"ponen",
"garla",
"const",
"rifen",
"iodis",
"temem",
"moder",
"pizza",
"savia",
"ovada",
"iodit",
"dacis",
"xopin",
"besam",
"salpe",
"fobia",
"mobli",
"dolar",
"fresa",
"iodes",
"xicra",
"ortiu",
"gloto",
"ollam",
"furat",
"regit",
"enrol",
"focid",
"rodol",
"simes",
"tiria",
"cafes",
"retol",
"belat",
"reigs",
"cimas",
"rosis",
"bucal",
"oible",
"mescs",
"taxau",
"crocs",
"ceiba",
"tresa",
"bisas",
"dieta",
"dinyo",
"animi",
"peria",
"brinc",
"ornau",
"raims",
"incoa",
"pixat",
"compt",
"semeu",
"regix",
"cussa",
"salut",
"molsa",
"lipid",
"final",
"mugia",
"encul",
"daten",
"criau",
"tasti",
"horda",
"dugem",
"toxic",
"nocer",
"amarr",
"noqui",
"emuls",
"julia",
"unglo",
"barns",
"glace",
"xeixs",
"donen",
"talps",
"aucau",
"baden",
"fureu",
"famul",
"oxima",
"casis",
"longa",
"xocar",
"cisin",
"dracs",
"enter",
"refia",
"telat",
"trote",
"cofia",
"popat",
"lacti",
"solls",
"llavi",
"allen",
"tapeu",
"senes",
"calbs",
"escar",
"llata",
"libar",
"vicio",
"filis",
"raspi",
"eludi",
"sisos",
"lleme",
"proto",
"sodis",
"maror",
"torus",
"xeres",
"reneg",
"vetem",
"filas",
"nafte",
"latex",
"gueto",
"empar",
"pruus",
"culta",
"acale",
"dreci",
"llima",
"arreu",
"diode",
"sumix",
"atans",
"havem",
"faeto",
"rosin",
"vagit",
"fileu",
"vanam",
"couen",
"trene",
"xitat",
"tromp",
"toves",
"casau",
"reieu",
"petam",
"doses",
"fanga",
"odora",
"uvees",
"vagis",
"panta",
"reuma",
"semar",
"baula",
"vulga",
"sexar",
"curis",
"ascla",
"local",
"tolix",
"xutam",
"jurco",
"podas",
"masec",
"oques",
"rajos",
"penis",
"adobi",
"covau",
"urpix",
"sepal",
"agbes",
"jaure",
"imida",
"canvi",
"resto",
"culla",
"ooide",
"gemiu",
"guiso",
"roigs",
"ricas",
"erice",
"coipu",
"deria",
"amena",
"brasa",
"crest",
"surfs",
"hissa",
"incoe",
"caiga",
"aloja",
"banau",
"voret",
"galop",
"gords",
"conec",
"esbuc",
"ofesa",
"erren",
"cordi",
"xuixe",
"innat",
"nuvol",
"motet",
"garli",
"volin",
"beure",
"guies",
"perli",
"calen",
"iridi",
"tibat",
"tesla",
"eluiu",
"duies",
"gelid",
"riqui",
"cotem",
"flamo",
"solat",
"migri",
"gomat",
"deseu",
"llami",
"ollao",
"sorge",
"folii",
"acens",
"xabec",
"maire",
"cegau",
"bosco",
"nanni",
"forro",
"orsin",
"asile",
"glans",
"ferit",
"burca",
"empas",
"nueta",
"cafre",
"pario",
"rapte",
"molau",
"cesis",
"brodi",
"hisop",
"ralle",
"costa",
"catau",
"jures",
"saler",
"galfo",
"ambos",
"xefla",
"quics",
"saimo",
"isard",
"seies",
"tacae",
"ofici",
"olivi",
"fenys",
"apugi",
"allar",
"dopau",
"viola",
"ondia",
"fonas",
"libel",
"emboç",
"carre",
"botia",
"xurra",
"canat",
"albes",
"lacro",
"maons",
"comal",
"borno",
"robem",
"ometa",
"tacit",
"tenue",
"pruia",
"criem",
"copeu",
"agueu",
"clina",
"ansat",
"toqui",
"sarri",
"marro",
"aguau",
"boten",
"llaut",
"boiem",
"podre",
"vacua",
"retix",
"espua",
"tible",
"ciava",
"astes",
"garro",
"bries",
"tenir",
"veral",
"calma",
"liana",
"verem",
"burlo",
"jonec",
"moleu",
"xifro",
"orava",
"cotar",
"pivet",
"remug",
"algal",
"mames",
"xuixa",
"celes",
"guias",
"cabit",
"arnas",
"aliga",
"broto",
"vexen",
"bresc",
"avivo",
"serbi",
"mapes",
"anise",
"fulla",
"gruau",
"tupeu",
"ajace",
"alças",
"balix",
"imper",
"blens",
"prada",
"engeg",
"cuats",
"oliis",
"fangs",
"gosis",
"tagal",
"coris",
"afuin",
"coent",
"rajar",
"verba",
"monyo",
"afuas",
"nafri",
"vidua",
"tolls",
"barbo",
"senil",
"reses",
"carib",
"renyo",
"nates",
"forra",
"oiosa",
"bleva",
"suosa",
"ratam",
"maura",
"repes",
"enroc",
"seras",
"formo",
"tudar",
"opine",
"tocar",
"garts",
"difam",
"riero",
"negra",
"plani",
"xopat",
"xaies",
"diazo",
"zains",
"adeso",
"indag",
"antic",
"blego",
"mugro",
"omisa",
"sogra",
"gabis",
"compr",
"bacil",
"islam",
"assoc",
"mirar",
"ovnis",
"damna",
"trobo",
"fallo",
"salud",
"aorta",
"trama",
"garsa",
"movia",
"nevus",
"tafur",
"minen",
"greca",
"armau",
"somii",
"paixa",
"exsud",
"minva",
"dinda",
"alçur",
"canac",
"gasso",
"eruga",
"inxes",
"obeia",
"melca",
"allet",
"amits",
"jugam",
"rasam",
"tiros",
"pudes",
"llets",
"gemeg",
"ciant",
"geoda",
"sordo",
"arnau",
"figur",
"beque",
"gusti",
"conve",
"tossi",
"firal",
"segur",
"burli",
"agrad",
"colam",
"natal",
"mugit",
"comas",
"topat",
"veler",
"plori",
"camus",
"domti",
"vanar",
"sedau",
"clics",
"zooms",
"blufs",
"resas",
"salpo",
"folcs",
"engom",
"metes",
"porta",
"motor",
"folla",
"argui",
"grisa",
"molia",
"hansa",
"genic",
"nolis",
"uqueu",
"coler",
"estre",
"sulsi",
"honor",
"solam",
"xarpa",
"nomeu",
"triga",
"setze",
"planx",
"bitxa",
"quasi",
"femam",
"allev",
"ronxe",
"tafia",
"estuc",
"armis",
"flaps",
"capci",
"parat",
"manoi",
"metjo",
"vudus",
"demor",
"mudis",
"ablam",
"gaube",
"bifis",
"refut",
"calls",
"oiant",
"glops",
"buosa",
"copsa",
"darga",
"enfel",
"luges",
"queri",
"locul",
"avala",
"taram",
"mimem",
"marco",
"pelfa",
"badin",
"vetas",
"gasam",
"irisi",
"musau",
"tatui",
"olive",
"reton",
"orbis",
"xoque",
"boina",
"evoco",
"perca",
"acero",
"tinys",
"atest",
"curul",
"furgo",
"maxim",
"ficam",
"nadiu",
"jonia",
"lliri",
"cabot",
"bufem",
"alans",
"basco",
"ungla",
"fruir",
"triti",
"grats",
"intro",
"false",
"cruel",
"donam",
"ascle",
"mosts",
"llava",
"piles",
"llora",
"rancs",
"premo",
"virot",
"avese",
"fonem",
"esteu",
"trepa",
"renoi",
"copro",
"obrem",
"ritus",
"curia",
"dames",
"forco",
"atony",
"diesi",
"cabeu",
"timpa",
"orgue",
"perns",
"finte",
"binar",
"cells",
"sonos",
"nacra",
"venal",
"culli",
"biaix",
"meneu",
"sopin",
"fajos",
"irrit",
"esmis",
"detur",
"doten",
"baria",
"pauls",
"ficau",
"nadin",
"serie",
"guari",
"paieu",
"saria",
"pudic",
"linxs",
"xacra",
"verse",
"edens",
"colin",
"cimin",
"tussi",
"nexia",
"ocros",
"endus",
"capes",
"cansi",
"samoa",
"morat",
"xiule",
"opila",
"ampla",
"mimam",
"gafet",
"tions",
"roter",
"aftos",
"seura",
"cants",
"sabea",
"surem",
"cites",
"prein",
"espad",
"asili",
"giteu",
"capaç",
"eolic",
"herba",
"estoc",
"aqueu",
"frega",
"biota",
"libem",
"botid",
"dicto",
"magre",
"farsa",
"olies",
"celeu",
"devot",
"alena",
"pelau",
"tampa",
"pesca",
"joves",
"foren",
"guano",
"toret",
"orbin",
"bavas",
"derog",
"gouda",
"dunar",
"copia",
"causo",
"insti",
"aineu",
"dinye",
"emeto",
"calca",
"salam",
"creui",
"varen",
"coien",
"conte",
"direu",
"varec",
"amaço",
"balim",
"trobi",
"afamo",
"centr",
"sidos",
"mants",
"ungim",
"pispe",
"azida",
"adobo",
"dosis",
"pispo",
"jacti",
"sabor",
"atuim",
"amera",
"passi",
"titll",
"fetid",
"doset",
"tebia",
"nubil",
"veseu",
"purga",
"litxi",
"cepat",
"troia",
"arpam",
"rullo",
"hague",
"colis",
"metis",
"prole",
"brama",
"crise",
"escod",
"piuem",
"visar",
"balec",
"maori",
"vanem",
"luxin",
"tibau",
"caveu",
"estib",
"cucau",
"corda",
"ofega",
"polie",
"hindu",
"rugit",
"roncs",
"torxo",
"oesca",
"apura",
"venus",
"xorre",
"urpat",
"ombre",
"sivan",
"autos",
"quina",
"torta",
"usava",
"venen",
"occiu",
"duros",
"bombo",
"demes",
"actuu",
"vests",
"butza",
"jeuen",
"iodat",
"occit",
"luxos",
"acusa",
"vinte",
"lluna",
"afoll",
"entim",
"sacam",
"mulla",
"avort",
"absol",
"amorr",
"reles",
"escue",
"isidi",
"disti",
"gajos",
"costs",
"ovids",
"serfs",
"griva",
"caoba",
"aidin",
"quill",
"sabir",
"catet",
"rimas",
"bonas",
"pugeu",
"vioni",
"raimi",
"hipic",
"baveu",
"vexat",
"lates",
"sobec",
"erram",
"pouau",
"liceu",
"apiad",
"punir",
"paiem",
"trami",
"diton",
"ombro",
"flori",
"aeris",
"viots",
"soldo",
"celin",
"apiny",
"moria",
"beisa",
"pelis",
"vexin",
"lesos",
"pigot",
"poruc",
"vibra",
"rodam",
"engan",
"ajuts",
"rapau",
"xiten",
"dista",
"nuosa",
"engir",
"vogir",
"hajar",
"boram",
"salen",
"ampre",
"jugau",
"riber",
"alien",
"ideen",
"pucer",
"borja",
"cercs",
"fenyo",
"brive",
"xoric",
"cacen",
"basau",
"xafas",
"bleis",
"espas",
"cerna",
"cegas",
"balis",
"plaer",
"fites",
"caleu",
"firau",
"cercl",
"vedat",
"tipes",
"flats",
"boldo",
"callo",
"agita",
"llirs",
"corma",
"uixer",
"crups",
"matau",
"frisa",
"aparc",
"tsuga",
"ordes",
"boles",
"allau",
"lliur",
"nanna",
"talli",
"orseu",
"fireu",
"torxa",
"calfa",
"silva",
"abusi",
"ajuda",
"macos",
"xafem",
"vivia",
"baser",
"fenem",
"crims",
"grada",
"botet",
"caçau",
"cugul",
"grues",
"gambe",
"molto",
"atxes",
"setra",
"sotja",
"pagre",
"ferre",
"rapid",
"piuin",
"ponts",
"remin",
"eslau",
"hemio",
"rella",
"omeda",
"cusin",
"aiden",
"afilo",
"coron",
"arnam",
"rascl",
"xeric",
"minin",
"drets",
"xaqui",
"prova",
"remet",
"cause",
"cucut",
"fongo",
"irada",
"empri",
"opera",
"expil",
"error",
"jagut",
"banus",
"anets",
"domin",
"obsta",
"saulo",
"torbs",
"tords",
"sumis",
"escui",
"miasi",
"binau",
"oisca",
"tolem",
"valid",
"venja",
"vexeu",
"alege",
"faigs",
"unica",
"acidi",
"dinam",
"olivo",
"datxa",
"fitxo",
"avant",
"burgi",
"parin",
"haura",
"dulls",
"tuejo",
"anses",
"rusca",
"pevet",
"mugic",
"fotjo",
"jueus",
"covar",
"aptot",
"penya",
"mutil",
"digna",
"escou",
"escoi",
"saies",
"pacta",
"ancut",
"golos",
"sanem",
"pacti",
"lloin",
"mamia",
"vexau",
"trino",
"ortos",
"vases",
"rossi",
"rapaç",
"tomat",
"lords",
"esbos",
"fisic",
"ficas",
"ovula",
"colem",
"ricat",
"ocume",
"iglus",
"lluir",
"fruit",
"viuda",
"arneu",
"alier",
"sopau",
"anyoc",
"ronca",
"xaien",
"boiri",
"sarna",
"autes",
"cavar",
"eixal",
"rebli",
"gemis",
"gavot",
"ruixe",
"badia",
"auixe",
"admes",
"actiu",
"cuots",
"batec",
"gurus",
"deliu",
"torri",
"fiscs",
"ouera",
"esmus",
"flint",
"segas",
"reats",
"aucar",
"peleu",
"curat",
"fotut",
"ragui",
"mudar",
"aferm",
"gique",
"murta",
"obrat",
"mular",
"bores",
"amble",
"noten",
"apame",
"cavis",
"tibam",
"gasem",
"ecidi",
"airis",
"obeir",
"morfi",
"cegui",
"odien",
"fetge",
"salaç",
"miole",
"prasi",
"rampi",
"fumem",
"ombus",
"idein",
"farad",
"cinto",
"femta",
"fines",
"eixir",
"aduna",
"estau",
"pugno",
"orsam",
"bufet",
"piola",
"seent",
"sonar",
"greal",
"talec",
"canca",
"tipic",
"emirs",
"tiben",
"nivos",
"dalle",
"cedia",
"obrir",
"esmat",
"adoro",
"ofidi",
"adiin",
"gabam",
"cient",
"vetll",
"orbas",
"tijat",
"escos",
"rebec",
"erras",
"crols",
"ofren",
"hores",
"gitin",
"rabic",
"atica",
"cuguç",
"cadup",
"arque",
"adiar",
"trobe",
"renis",
"nedol",
"saldo",
"peteu",
"guiny",
"lique",
"fitxe",
"esmeu",
"oasis",
"terça",
"arile",
"podra",
"xumam",
"valen",
"anfos",
"viono",
"repel",
"volem",
"tarem",
"solar",
"aboca",
"balca",
"falsi",
"xuten",
"color",
"velem",
"tranc",
"fumar",
"jover",
"opugn",
"afama",
"gruem",
"salva",
"coral",
"ultro",
"ganxa",
"menor",
"marri",
"trons",
"apoda",
"seria",
"anodi",
"arnem",
"taure",
"ideau",
"veles",
"mapem",
"grife",
"llapa",
"lasca",
"xopen",
"cotam",
"vexar",
"sotes",
"empac",
"retra",
"fiada",
"fuels",
"atrit",
"riell",
"fitam",
"onsos",
"resen",
"xucla",
"capen",
"penat",
"barem",
"musas",
"firar",
"vuits",
"envio",
"afixe",
"eduix",
"metxa",
"rials",
"envai",
"drogo",
"patge",
"himne",
"vists",
"rissa",
"polsi",
"ajaça",
"ferir",
"dardo",
"nacio",
"borsa",
"tatus",
"vesau",
"vanos",
"xutis",
"xiscl",
"tabul",
"fermi",
"cuini",
"ainen",
"orsai",
"dardi",
"astur",
"balou",
"laxas",
"molin",
"zigot",
"medes",
"fugit",
"plats",
"vives",
"terns",
"badeu",
"lledo",
"noent",
"papus",
"clisi",
"furan",
"cumel",
"flora",
"adule",
"finis",
"alzin",
"erina",
"calba",
"amani",
"gojat",
"duals",
"gisca",
"orino",
"lider",
"vinca",
"tupem",
"pugna",
"napar",
"ufana",
"sagno",
"novia",
"esgai",
"rural",
"cavau",
"capar",
"colco",
"moixo",
"afone",
"molal",
"acusi",
"rager",
"pulla",
"lucri",
"engul",
"collo",
"boneg",
"encir",
"elidi",
"quota",
"malle",
"ludio",
"morin",
"audio",
"solsi",
"quere",
"banyi",
"ajeia",
"amido",
"liqui",
"matat",
"nadir",
"emmel",
"melis",
"nogue",
"pells",
"rotlo",
"erols",
"pesar",
"deler",
"botin",
"boxam",
"afibl",
"creis",
"osmic",
"cetil",
"rajat",
"tonem",
"sogue",
"botiu",
"unint",
"llevi",
"capol",
"ermau",
"manil",
"ucara",
"baten",
"paeix",
"cigar",
"armat",
"rebla",
"fruis",
"exorn",
"glaça",
"valse",
"raura",
"guiat",
"crasi",
"nomer",
"esbaf",
"frare",
"adopt",
"oiran",
"plata",
"socis",
"units",
"cavec",
"aireu",
"light",
"ronxi",
"ganyo",
"crega",
"busco",
"anada",
"elemi",
"varis",
"xacam",
"saque",
"saons",
"canic",
"eixau",
"tapam",
"armen",
"vaire",
"ajude",
"capte",
"urçol",
"briso",
"cerra",
"bujol",
"pegas",
"setii",
"morro",
"uncio",
"cotin",
"cuida",
"rabia",
"jorns",
"ateus",
"petat",
"nyaca",
"enema",
"sadic",
"tuber",
"epica",
"munya",
"macat",
"jonca",
"papis",
"uissi",
"sinus",
"maseg",
"atiau",
"obvio",
"apuge",
"varia",
"baixo",
"privi",
"treme",
"sabia",
"peiot",
"donin",
"fruiu",
"nocat",
"borne",
"citin",
"plano",
"xuits",
"hagut",
"arrui",
"troca",
"tripa",
"estot",
"pujat",
"serra",
"agusa",
"panys",
"piule",
"albor",
"difos",
"sorro",
"relax",
"agnus",
"copio",
"pille",
"gauss",
"murto",
"mudas",
"ninoi",
"subve",
"cimar",
"cirer",
"culem",
"fluit",
"ramis",
"seito",
"dento",
"raimo",
"xaias",
"agata",
"afirm",
"robes",
"tenia",
"apren",
"creau",
"fecal",
"doteu",
"ajeis",
"sento",
"juram",
"tanco",
"tsade",
"empan",
"boixa",
"bomba",
"balls",
"casba",
"ovale",
"lliça",
"ranid",
"duble",
"gamoi",
"vulpi",
"ramam",
"dosas",
"imido",
"talen",
"rajas",
"sabem",
"libia",
"celta",
"comat",
"humic",
"sopeu",
"ornas",
"ovali",
"gaita",
"vetar",
"tenaç",
"fuets",
"faceu",
"bacul",
"vengi",
"pream",
"cecal",
"lacia",
"bagol",
"rafal",
"admet",
"ullam",
"adoba",
"apoca",
"reixi",
"dubto",
"dreni",
"fluid",
"pecau",
"bovid",
"bigam",
"nocar",
"atiat",
"groga",
"arome",
"viatj",
"taper",
"saboc",
"obras",
"afoni",
"nimba",
"orejo",
"noque",
"queia",
"mioce",
"rosen",
"manin",
"carps",
"viava",
"sipar",
"tonya",
"xifra",
"pugen",
"nedau",
"grall",
"pegui",
"rapeu",
"eduiu",
"plepa",
"escuu",
"amura",
"cable",
"copen",
"xacau",
"culen",
"enzes",
"xacas",
"acoro",
"potol",
"rollo",
"dreça",
"udolo",
"prope",
"gesti",
"piula",
"betum",
"inici",
"oldra",
"pixes",
"manna",
"brusa",
"burxa",
"pedal",
"acida",
"agite",
"albat",
"trieu",
"balun",
"fique",
"joell",
"ouats",
"xisca",
"paren",
"menti",
"basso",
"emula",
"anota",
"exons",
"monts",
"adono",
"cerni",
"alarb",
"amaga",
"fuges",
"pudiu",
"boteu",
"tumid",
"apuri",
"preau",
"posis",
"tarro",
"ploga",
"furor",
"rasis",
"credo",
"espai",
"stilb",
"azule",
"brucs",
"bambo",
"jovia",
"provo",
"piues",
"dallo",
"joies",
"emets",
"plaus",
"somes",
"nitro",
"puada",
"usurp",
"abill",
"unfle",
"guisi",
"perlo",
"sarja",
"bollo",
"punxo",
"vesas",
"pogui",
"oiois",
"adune",
"tusta",
"decal",
"rengs",
"linia",
"moler",
"botre",
"anats",
"place",
"marxi",
"items",
"grega",
"artet",
"segle",
"cuirs",
"dolen",
"emeta",
"setge",
"calem",
"egeus",
"babui",
"bloco",
"papam",
"hajau",
"pensi",
"manem",
"engaf",
"panis",
"plebs",
"gussi",
"forcs",
"roder",
"iarda",
"barbi",
"octau",
"garra",
"edita",
"vacil",
"audit",
"tibem",
"pella",
"adven",
"tirre",
"serum",
"quiti",
"apane",
"sacse",
"suqui",
"veçot",
"ronso"];
|
ffrancesc/absurdle.cat
|
src/components/modals/InfoModal.tsx
|
<gh_stars>0
import { Fragment } from "react";
import { Dialog, Transition } from "@headlessui/react";
import { Cell } from "../grid/Cell";
type Props = {
isOpen: boolean;
handleClose: () => void;
};
export const InfoModal = ({ isOpen, handleClose }: Props) => {
return (
<Transition.Root show={isOpen} as={Fragment}>
<Dialog
as="div"
className="fixed z-10 inset-0 overflow-y-auto"
onClose={handleClose}
>
<div className="flex items-end justify-center min-h-screen pt-4 px-4 pb-20 text-center sm:block sm:p-0">
<Transition.Child
as={Fragment}
enter="ease-out duration-300"
enterFrom="opacity-0"
enterTo="opacity-100"
leave="ease-in duration-200"
leaveFrom="opacity-100"
leaveTo="opacity-0"
>
<Dialog.Overlay className="fixed inset-0 bg-gray-500 bg-opacity-75 transition-opacity" />
</Transition.Child>
{/* This element is to trick the browser into centering the modal contents. */}
<span
className="hidden sm:inline-block sm:align-middle sm:h-screen"
aria-hidden="true"
>
​
</span>
<Transition.Child
as={Fragment}
enter="ease-out duration-300"
enterFrom="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
enterTo="opacity-100 translate-y-0 sm:scale-100"
leave="ease-in duration-200"
leaveFrom="opacity-100 translate-y-0 sm:scale-100"
leaveTo="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
>
<div className="inline-block align-bottom bg-white rounded-lg px-4 pt-5 pb-4 text-left overflow-hidden shadow-xl transform transition-all sm:my-8 sm:align-middle sm:max-w-sm sm:w-full sm:p-6">
<div>
<div className="text-center">
<Dialog.Title
as="h3"
className="text-lg leading-6 font-medium text-gray-900"
>
Com jugar
</Dialog.Title>
<div className="mt-2">
<p className="text-sm text-gray-500">
Endevina el WORDLE.
Has d'introduir paraules de 5 lletres que existeixen i fer clic a ENTER.
Després de cada intent, el color de les lletres canviarà per indicar l'evolució de la partida.
No es tenen en compte els accents a l'hora d'introduir paraules.
Es poden repetir lletres.
</p>
<div className="flex justify-center mb-1 mt-4">
<Cell value="P" hint="correct" />
<Cell value="I" />
<Cell value="L" />
<Cell value="O" />
<Cell value="T" />
</div>
<p className="text-sm text-gray-500">
La lletra P es troba en el lloc correcte de la paraula.
</p>
<div className="flex justify-center mb-1 mt-4">
<Cell value="D" />
<Cell value="O" />
<Cell value="T" hint="present" />
<Cell value="Z" />
<Cell value="E" />
</div>
<p className="text-sm text-gray-500">
La paraula té la lletra T però en un altre lloc.
</p>
<div className="flex justify-center mb-1 mt-4">
<Cell value="V" />
<Cell value="A" />
<Cell value="G" />
<Cell value="U" hint="absent" />
<Cell value="E" />
</div>
<p className="text-sm text-gray-500">
La paraula no conté la lletra I.
</p>
</div>
</div>
</div>
</div>
</Transition.Child>
</div>
</Dialog>
</Transition.Root>
);
};
|
ffrancesc/absurdle.cat
|
src/lib/game.ts
|
export type Hint = "absent" | "correct" | "present";
export interface Guess {guess: string, hints: Hint[]};
|
ffrancesc/absurdle.cat
|
src/lib/share.ts
|
<reponame>ffrancesc/absurdle.cat
import { Hint } from "./game";
export const shareStatus = (hints: Hint[][]) => {
navigator.clipboard.writeText(
`Absurdle en ${hints.length} intents:\n\n` +
generateEmojiGrid(hints)
);
};
const showHint = (hint: Hint): string => {
switch (hint) {
case "correct":
return "🟩";
case "present":
return "🟨";
case "absent":
return "⬜";
}
}
export const generateEmojiGrid = (hints: Hint[][]) => {
return hints
.map((hints) => {
return hints.map(showHint).concat();
})
.join("\n");
};
|
ffrancesc/absurdle.cat
|
src/components/keyboard/Key.tsx
|
<reponame>ffrancesc/absurdle.cat
import { ReactNode } from "react";
import classnames from "classnames";
import { KeyValue } from "../../lib/keyboard";
type Props = {
children?: ReactNode;
value: KeyValue;
disabled: boolean;
className?: String;
onClick: (value: KeyValue) => void;
};
export const Key = ({
children,
disabled,
className,
value,
onClick,
}: Props) => {
const classes = classnames(
"flex items-center justify-center rounded mx-0.5 text-xs font-bold cursor-pointer h-14 w-12",
className,
disabled?
"bg-slate-400 text-white" :
"bg-slate-200 hover:bg-slate-300 active:bg-slate-400"
);
return (
<div className={classes} onClick={() => onClick(value)}>
{children || value}
</div>
);
};
|
ffrancesc/absurdle.cat
|
src/lib/keyboard.ts
|
<filename>src/lib/keyboard.ts
export type KeyValue = Char | "Enter" | "Backspace";
export const chars = [
"Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
"A", "S", "D", "F", "G", "H", "J", "K", "L", "Ç",
"Z", "X", "C", "V", "B", "N", "M"] as const;
export type Char = typeof chars[number];
|
ffrancesc/absurdle.cat
|
src/components/grid/Cell.tsx
|
import { Hint } from "../../lib/game";
import classnames from "classnames";
import { Transition } from "@headlessui/react";
import './Cell.css';
type Props = {
value?: string;
hint?: Hint;
index?: number;
};
export const Cell = ({ value, hint, index = 0 }: Props) => {
const color = classnames(
{
"bg-white border-slate-200": !hint,
"bg-slate-400 text-white border-slate-400": hint === "absent",
"bg-green-500 text-white border-green-500": hint === "correct",
"bg-yellow-500 text-white border-yellow-500": hint === "present",
},
"my-class"
);
const transition = classnames(
"transform transition ease-in-out duration-800ms",
`cdelay-${index}`,
)
return (
<Transition
show={true}
appear={value !== undefined}
enter={transition}
enterFrom="opacity-75"
enterTo={`opacity-100 scale-100 ${color}`}
entered={color}
className="w-14 h-14 border-solid border-2 flex items-center justify-center mx-0.5 text-lg font-bold rounded"
>
{value}
</Transition>
);
};
|
ffrancesc/absurdle.cat
|
src/components/grid/Grid.tsx
|
<reponame>ffrancesc/absurdle.cat
import React, { useRef, useEffect } from "react";
import { Hint } from "../../lib/game";
import { Row } from "./Row";
type Props = {
guesses: { guess: string, hints: Hint[] }[];
currentGuess: string;
};
export const Grid = ({ guesses, currentGuess }: Props) => {
const currentRow = useRef<null | HTMLDivElement>(null);
const scrollToBottom = () => {
if (currentRow.current) currentRow.current.scrollIntoView({
behavior: "smooth",
block: "start",
});
};
useEffect(() => {
scrollToBottom()
});
return (
<div className="overflow-y-auto grow">
{guesses.map(({ guess, hints }, i) => (
<Row key={i} guess={guess} hints={hints} />
))}
<Row innerRef={currentRow} guess={currentGuess} />
</div>
);
};
|
jmfirth/design-test-harness
|
src/components/grid.ts
|
<filename>src/components/grid.ts
import { TemplateResult } from 'lit-html'
import { html } from 'lit-html/lib/lit-extended'
import * as colors from '../colors'
import { rgba } from '../common'
import { Breakpoints, Grid } from '../config'
export const grid = (breakpoints: Breakpoints, grid: Grid) => html`
<div class="harness-grid">
<style type="text/css">
.harness-grid {
position: absolute;
top: 0;
bottom: 0;
left: 0;
right: 0;
display: grid;
grid-template-columns: repeat(${grid.columns}, 1fr);
grid-gap: 3px;
z-index: 99999999999;
background: none !important;
}
@media (min-width: ${breakpoints.mobile}px) {
.harness-grid {
left: 50%;
width: ${grid.container.mobile}px;
margin-left: -${grid.container.mobile / 2}px;
/* grid-template-columns: repeat($grid-columns, $mobile-grid-column); */
grid-gap: ${grid.gutters.mobile}px;
}
}
@media (min-width: ${breakpoints.tablet}px) {
.harness-grid {
width: ${grid.container.tablet}px;
margin-left: -${grid.container.tablet / 2}px;
/* grid-template-columns: repeat($grid-columns, $tablet-grid-column); */
grid-gap: ${grid.gutters.tablet}px;
}
}
@media (min-width: ${breakpoints.smallDesktop}px) {
.harness-grid {
width: ${grid.container.smallDesktop}px;
margin-left: -${grid.container.smallDesktop / 2}px;
/* grid-template-columns: repeat($grid-columns, $sm-desktop-grid-column); */
grid-gap: ${grid.gutters.tablet}px;
}
}
@media (min-width: ${breakpoints.largeDesktop}px) {
.harness-grid {
width: ${grid.container.largeDesktop}px;
margin-left: -${grid.container.largeDesktop / 2}px;
/* grid-template-columns: repeat($grid-columns, $lg-desktop-grid-column); */
grid-gap: ${grid.gutters.tablet}px;
}
}
.harness-grid__column {
grid-column-gap: 3em;
background-color: ${rgba(colors.carnation, 0.15)};
border: 1px solid ${rgba(colors.carnation, 0.25)};
border-top: none;
border-bottom: none;
}
</style>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
<div class="harness-grid__column"></div>
</div>
`
|
jmfirth/design-test-harness
|
src/config.ts
|
<filename>src/config.ts
import * as t from 'io-ts'
export const Breakpoints = t.interface({
mobile: t.number,
tablet: t.number,
smallDesktop: t.number,
largeDesktop: t.number
})
export interface Breakpoints extends t.TypeOf<typeof Breakpoints> {}
export type Breakpoint = keyof Breakpoints
export const breakpoints: Breakpoint[] = ['largeDesktop', 'smallDesktop', 'tablet', 'mobile']
export const Grid = t.interface({
columns: t.number,
gutters: Breakpoints,
container: Breakpoints
})
export interface Grid extends t.TypeOf<typeof Grid> {}
export const Config = t.interface({
breakpoints: Breakpoints,
grid: t.union([Grid, t.undefined])
})
export interface Config extends t.TypeOf<typeof Config> {}
export function isConfig(obj: any): obj is Config {
return obj && Breakpoints.is(obj.breakpoints) && Grid.is(obj.grid)
}
export function getHeight(): number {
return Math.max(document.documentElement.clientHeight, window.innerHeight || 0)
}
export function getWidth(): number {
return Math.max(document.documentElement.clientWidth, window.innerWidth || 0)
}
export function getBreakpoints(config: Config): Breakpoints | undefined {
return config ? config.breakpoints : undefined
}
export function getBreakpoint(config: Config): Breakpoint | undefined {
const height = getHeight()
return breakpoints.reduce((a, v) => (a || config.breakpoints[v] >= height ? a : v))
}
export function getGridColumn(config: Config) {
const height = getHeight()
const width = getWidth()
const breakpoint = getBreakpoint(config)
// config.grid.columns
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.