ngx-techlify-core 19.0.0 → 22.3.0

package/fesm2022/ngx-techlify-core-base-model-oCILHkdE.mjs

@@ -0,0 +1,677 @@
+import { J as EnvironmentService, X as AlertService, Y as FormValidatorService } from "./ngx-techlify-core-shared.module-DROe5GRx.mjs";
+import * as i0 from "@angular/core";
+import { Directive, ElementRef, EventEmitter, HostAttributeToken, Injectable, Input, Optional, Output, inject } from "@angular/core";
+import { finalize, fromEvent, merge, of } from "rxjs";
+import { debounceTime as debounceTime$1, distinctUntilChanged as distinctUntilChanged$1, filter, finalize as finalize$1, map as map$1, skip, startWith as startWith$1 } from "rxjs/operators";
+import { Title } from "@angular/platform-browser";
+import * as i1 from "@angular/router";
+import { ActivatedRoute, convertToParamMap } from "@angular/router";
+import * as i2 from "@angular/common";
+import { fakeAsync, tick } from "@angular/core/testing";
+var TechlifyService = class {
+	constructor(http, baseUrl) {
+		this.http = http;
+		this.baseUrl = "you-forgot-to-set-a-base-url";
+		this.baseUrl = baseUrl;
+	}
+	index(params, isCache) {
+		if (isCache) return this.http.cache().get(`api/${this.baseUrl}`, { params });
+		return this.http.get(`api/${this.baseUrl}`, { params });
+	}
+	store(model, params) {
+		return this.http.post(`api/${this.baseUrl}`, model, { params });
+	}
+	show(modelId, params) {
+		return this.http.get(`api/${this.baseUrl}/${modelId}`, { params });
+	}
+	update(model, params) {
+		return this.http.put(`api/${this.baseUrl}/${model.id}`, model, { params });
+	}
+	delete(model) {
+		return this.http.delete(`api/${this.baseUrl}/${model.id}`);
+	}
+};
+var TechlifyFormComponent = class TechlifyFormComponent {
+	constructor(formValidatorService, service) {
+		this.formValidatorService = formValidatorService;
+		this.service = service;
+		this.isWorking = false;
+		this.createdEntries = [];
+		this.isUpdate = false;
+		this.isAllowCreateAnother = true;
+		this.success = new EventEmitter();
+		this.alertService = inject(AlertService, { optional: true });
+	}
+	submit(model) {
+		this.form.markAllAsTouched();
+		if (!this.service) throw new Error(`${this.constructor.name}: Service is required to submit the form`);
+		if (!this.form.valid) return;
+		if (!model) model = this.form.value;
+		this.isWorking = true;
+		(this.isUpdate ? this.service.update(model) : this.service.store(model)).pipe(finalize(() => this.isWorking = false)).subscribe((res) => {
+			this.createdEntries.unshift(res?.item);
+			if (model?.is_create_another) {
+				this.alertService.addAlert("Successfully Created", "success");
+				return;
+			}
+			if (this.isUpdate) this.finalisedResponse(res?.item);
+			else this.finalisedResponse(this.createdEntries.length == 1 ? this.createdEntries[0] : this.createdEntries);
+		});
+	}
+	finalisedResponse(response) {
+		this.success.emit(response);
+		if (this.dialogRef) this.dialogRef.close(response);
+	}
+	closeDialog() {
+		if (this.createdEntries?.length > 0) this.success.emit(this.createdEntries);
+		if (this.dialogRef) this.dialogRef.close();
+	}
+	resetFieldValue(event, field) {
+		this.form?.get(field)?.setValue("");
+	}
+	getFieldValue(field) {
+		return this.form?.get(field)?.value;
+	}
+	isFieldValid(field) {
+		return this.formValidatorService.isFieldValid(field, this.form);
+	}
+	getErrorMessage(field) {
+		return this.formValidatorService.getErrorMessage(field, this.form, this.errorMessages);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: TechlifyFormComponent,
+			deps: [{ token: FormValidatorService }, {
+				token: TechlifyService,
+				optional: true
+			}],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			type: TechlifyFormComponent,
+			isStandalone: true,
+			inputs: {
+				isUpdate: "isUpdate",
+				isAllowCreateAnother: "isAllowCreateAnother"
+			},
+			outputs: { success: "success" },
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: TechlifyFormComponent,
+	decorators: [{ type: Directive }],
+	ctorParameters: () => [{ type: FormValidatorService }, {
+		type: TechlifyService,
+		decorators: [{ type: Optional }]
+	}],
+	propDecorators: {
+		isUpdate: [{ type: Input }],
+		isAllowCreateAnother: [{ type: Input }],
+		success: [{ type: Output }]
+	}
+});
+function techlifyFormContract(options) {
+	const fieldName = options.fieldName ?? "name";
+	const baseSubmitIt = options.hasCustomSubmit ? (() => void 0) : it;
+	describe("TechlifyFormComponent Contract", () => {
+		it("should pass a service to the base class", () => {
+			const component = options.getComponent();
+			expect(component.service).toBe(options.getService());
+		});
+		it("should initialize default values", () => {
+			const component = options.getComponent();
+			expect(component.isWorking).toBeFalse();
+			expect(component.isUpdate).toBeFalse();
+			expect(component.isAllowCreateAnother).toBeTrue();
+			expect(component.createdEntries).toEqual([]);
+		});
+		baseSubmitIt("should submit using store when creating", () => {
+			const component = options.getComponent();
+			component.form.patchValue({ [fieldName]: "Test" });
+			spyOn(component, "finalisedResponse");
+			options.getService().store.and.returnValue(of({ item: { id: 1 } }));
+			component.submit();
+			expect(options.getService().store).toHaveBeenCalledWith(component.form.value);
+			expect(component.createdEntries).toEqual([{ id: 1 }]);
+			expect(component.finalisedResponse).toHaveBeenCalled();
+		});
+		baseSubmitIt("should submit using update when isUpdate is true", () => {
+			const component = options.getComponent();
+			component.isUpdate = true;
+			component.form.patchValue({ [fieldName]: "Updated" });
+			spyOn(component, "finalisedResponse");
+			options.getService().update.and.returnValue(of({ item: { id: 1 } }));
+			component.submit();
+			expect(options.getService().update).toHaveBeenCalledWith(component.form.value);
+			expect(component.finalisedResponse).toHaveBeenCalledWith({ id: 1 });
+		});
+		it("should not submit invalid form", () => {
+			const component = options.getComponent();
+			component.form.setErrors({ invalid: true });
+			component.submit();
+			expect(options.getService().store).not.toHaveBeenCalled();
+		});
+		baseSubmitIt("should mark form as touched before submit", () => {
+			const component = options.getComponent();
+			spyOn(component.form, "markAllAsTouched");
+			component.submit();
+			expect(component.form.markAllAsTouched).toHaveBeenCalled();
+		});
+		baseSubmitIt("should set isWorking while submitting", () => {
+			const component = options.getComponent();
+			component.form.patchValue({ [fieldName]: "Test" });
+			options.getService().store.and.returnValue(of({ item: { id: 1 } }));
+			component.submit();
+			expect(component.isWorking).toBeFalse();
+		});
+		it("should emit success event on finalisedResponse", () => {
+			const component = options.getComponent();
+			spyOn(component.success, "emit");
+			component.finalisedResponse({ id: 1 });
+			expect(component.success.emit).toHaveBeenCalledWith({ id: 1 });
+		});
+		it("should close dialog on finalisedResponse when dialog exists", () => {
+			const component = options.getComponent();
+			component.dialogRef = { close: jasmine.createSpy("close") };
+			component.finalisedResponse({ id: 1 });
+			expect(component.dialogRef.close).toHaveBeenCalledWith({ id: 1 });
+		});
+		it("should reset field value", () => {
+			const component = options.getComponent();
+			component.form.patchValue({ [fieldName]: "Test" });
+			component.resetFieldValue(null, fieldName);
+			expect(component.getFieldValue(fieldName)).toBe("");
+		});
+		it("should return field value", () => {
+			const component = options.getComponent();
+			component.form.patchValue({ [fieldName]: "Test" });
+			expect(component.getFieldValue(fieldName)).toBe("Test");
+		});
+		it("should close dialog and emit created entries", () => {
+			const component = options.getComponent();
+			component.createdEntries = [{ id: 1 }];
+			component.dialogRef = { close: jasmine.createSpy("close") };
+			spyOn(component.success, "emit");
+			component.closeDialog();
+			expect(component.success.emit).toHaveBeenCalledWith([{ id: 1 }]);
+			expect(component.dialogRef.close).toHaveBeenCalled();
+		});
+	});
+}
+function parseLocalDate(dateStr) {
+	const [y, m, d] = dateStr.split("-").map(Number);
+	return new Date(y, m - 1, d);
+}
+var RequestHelperService = class RequestHelperService {
+	constructor(router, activatedRoute, datePipe) {
+		this.router = router;
+		this.activatedRoute = activatedRoute;
+		this.datePipe = datePipe;
+	}
+	updateFormWithQueryParams(formGroup, formConfig) {
+		this.updateFormWithParams(formGroup, this.activatedRoute.snapshot.queryParams, formConfig);
+	}
+	updateFormWithParams(formGroup, params, formConfig) {
+		for (const key in formGroup.controls) if (Object.prototype.hasOwnProperty.call(formGroup.controls, key) && params && Object.prototype.hasOwnProperty.call(params, key)) formGroup.get(key).patchValue(this.formatValue(params[key], formConfig?.[key]), { emitEvent: false });
+	}
+	convertToFormData(data) {
+		const newData = {};
+		for (const prop in data) if (Object.prototype.hasOwnProperty.call(data, prop)) {
+			if (Array.isArray(data[prop])) newData[prop] = data[prop].join(",");
+			else if (this.isDateString(data[prop])) newData[prop] = this.datePipe.transform(data[prop], "yyyy-MM-dd");
+			else newData[prop] = data[prop] ?? "";
+		}
+		return newData;
+	}
+	updateQueryParams(queryParams) {
+		return this.router.navigate([], {
+			relativeTo: this.activatedRoute,
+			queryParams,
+			queryParamsHandling: "merge"
+		});
+	}
+	formatValue(value, formGroupElement) {
+		if (value && formGroupElement?.multiple && formGroupElement?.multiple === true) return (value?.split(",")).map((val) => this.isNumeric(val) ? Number.parseInt(val) : val);
+		else if (value && formGroupElement?.date && formGroupElement?.date === true) return parseLocalDate(value);
+		else if (value && formGroupElement?.number && formGroupElement?.number === true) return Number.parseInt(value);
+		else if (value && formGroupElement?.boolean) return value === "true";
+		else return value;
+	}
+	isNumeric(str) {
+		if (typeof str !== "string") return false;
+		if (str.trim() === "") return false;
+		return !Number.isNaN(Number(str));
+	}
+	isDateString(value) {
+		if (typeof value !== "string") return false;
+		return /^\d{4}[-/](0[1-9]|1[0-2])[-/](0[1-9]|[12]\d|3[01])([T\s].*)?$/.test(value);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: RequestHelperService,
+			deps: [
+				{ token: i1.Router },
+				{ token: i1.ActivatedRoute },
+				{ token: i2.DatePipe }
+			],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: RequestHelperService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: RequestHelperService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => [
+		{ type: i1.Router },
+		{ type: i1.ActivatedRoute },
+		{ type: i2.DatePipe }
+	]
+});
+var TechlifyListComponent = class TechlifyListComponent {
+	get isWorking() {
+		return this._isWorking;
+	}
+	set isWorking(value) {
+		this._isWorking = value;
+		if (value) this.filterForm?.disable({ emitEvent: false });
+		else this.filterForm?.enable({ emitEvent: false });
+	}
+	get isFilterPatchFromRoute() {
+		return this._isFilterPatchFromRoute;
+	}
+	set isFilterPatchFromRoute(value) {
+		this._isFilterPatchFromRoute = value;
+	}
+	get pageTitle() {}
+	get filterDebounceTime() {
+		const filterTime = Number(this.environmentService?.get()?.filterTime);
+		return filterTime >= 0 ? filterTime : 500;
+	}
+	get filterTriggerAction() {
+		return String(this.environmentService?.get()?.filterAction ?? "") === "focusout" ? "focusout" : "keyup";
+	}
+	constructor(service) {
+		this.service = service;
+		this.models = [];
+		this.selectedModelIds = [];
+		this.isAllSelected = false;
+		this.page = 1;
+		this.perPage = 50;
+		this.lastPage = 0;
+		this.isViewLoaded = false;
+		this.columnConfigs = [];
+		this._isWorking = false;
+		this._isFilterPatchFromRoute = true;
+		this.titleService = inject(Title, { optional: true });
+		this.environmentService = inject(EnvironmentService, { optional: true });
+		this.hostElement = inject(ElementRef, { optional: true });
+		this.isSetPageTitle = inject(new HostAttributeToken("isSetPageTitle"), { optional: true }) !== "false";
+		this.requestHelperService = inject(RequestHelperService, { optional: true });
+		if (this.isSetPageTitle) {
+			const resolvedTitle = this.pageTitle && this.pageTitle.trim().length > 0 ? this.pageTitle : this.environmentService?.get().appTitle;
+			this.titleService?.setTitle(resolvedTitle);
+		}
+	}
+	listenFilterChanges() {
+		let filterChanges$ = this.filterForm.valueChanges.pipe(debounceTime$1(this.filterDebounceTime));
+		if (this.filterTriggerAction === "focusout") filterChanges$ = merge(this.filterForm.valueChanges.pipe(filter(() => !this.isTypingInFilter()), debounceTime$1(this.filterDebounceTime)), fromEvent(this.hostElement?.nativeElement ?? document, "focusout")).pipe(map$1(() => JSON.stringify(this.filterForm.getRawValue())), startWith$1(JSON.stringify(this.filterForm.getRawValue())), distinctUntilChanged$1(), skip(1));
+		filterChanges$.subscribe((_) => {
+			if (this.isFilterPatchFromRoute) {
+				const unformatedFilters = JSON.parse(JSON.stringify(this.filterForm.value));
+				this.filters = this.requestHelperService?.convertToFormData(unformatedFilters);
+				this.requestHelperService?.updateQueryParams(this.filters);
+			}
+			this.reload();
+		});
+	}
+	isTypingInFilter() {
+		const element = document.activeElement;
+		return (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement && !["checkbox", "radio"].includes(element.type)) && !!this.hostElement?.nativeElement.contains(element);
+	}
+	patchFiltersFromRoute() {
+		this.requestHelperService?.updateFormWithQueryParams(this.filterForm, this.filterFormConfiguration);
+	}
+	loadData(filters) {
+		if (!this.service) throw new Error(`${this.constructor.name}: Service is required to load the data`);
+		this.isWorking = true;
+		if (!filters) {
+			filters = this.requestHelperService?.convertToFormData(JSON.parse(JSON.stringify(this.filterForm.value)));
+			filters.page = this.page;
+			filters.per_page = this.perPage;
+		}
+		this.service.index(filters).pipe(finalize$1(() => this.isWorking = false)).subscribe((result) => {
+			this.lastPage = result?.last_page || this.page;
+			if (result?.data?.length > 0) this.models = this.models.concat(result.data);
+		});
+	}
+	reload() {
+		this.models = [];
+		this.selectedModelIds = [];
+		this.page = 1;
+		if (!this.isWorking) this.loadData();
+	}
+	onScroll() {
+		if (!this.isWorking && this.page < this.lastPage) {
+			this.page += 1;
+			this.loadData();
+		}
+	}
+	resetFilter(field) {
+		this.filterForm.get(field).reset("");
+	}
+	modelsUpdatedById(models) {
+		if (!Array.isArray(models)) models = [models];
+		models.forEach((updatedModel) => {
+			const index = this.models.findIndex((m) => m.id === updatedModel.id);
+			if (index !== -1) this.models[index] = updatedModel;
+		});
+		this.models = [...this.models];
+	}
+	modelsDeletedById(models) {
+		if (!Array.isArray(models)) models = [models];
+		this.models = this.models.filter((m) => !models.some((item) => item.id === m.id));
+	}
+	clearSelectedModels() {
+		this.selectedModelIds = [];
+	}
+	modelCreated(model) {
+		if (Array.isArray(model)) this.models.unshift(...model);
+		else this.models.unshift(model);
+		this.models = [...this.models];
+	}
+	selectAll() {
+		this.selectedModelIds = [];
+		this.models.map((model) => {
+			model.is_selected = this.isAllSelected;
+			if (this.isAllSelected) this.selectedModelIds.push(model.id);
+		});
+		this.models = [...this.models];
+	}
+	isSelectionModified(event, model) {
+		this.isAllSelected = false;
+		if (event.checked) this.selectedModelIds.push(model?.id);
+		else this.selectedModelIds = this.selectedModelIds.filter((modelId) => modelId != model?.id);
+	}
+	sortColumn(event) {
+		const direction = event.direction.toString().toUpperCase();
+		this.models = [];
+		this.filterForm.get("sort_by").setValue(`${event?.active}|${direction}`);
+	}
+	resetFilterForm() {
+		if (this.filterForm) this.filterForm.reset();
+	}
+	resetColumnConfigs() {
+		this.columnConfigs = [];
+	}
+	setView(view) {
+		this.requestHelperService?.updateQueryParams({});
+		this.isViewLoaded = false;
+		this.resetColumnConfigs();
+		this.resetFilterForm();
+		setTimeout(() => {
+			if (view) {
+				this.requestHelperService?.updateFormWithParams(this.filterForm, view?.filters, this.filterFormConfiguration);
+				this.columnConfigs.forEach((column) => {
+					column.isSelected = (view?.columns).some((col) => col === column.def);
+				});
+			}
+			this.isViewLoaded = true;
+		}, 500);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: TechlifyListComponent,
+			deps: [{
+				token: TechlifyService,
+				optional: true
+			}],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			type: TechlifyListComponent,
+			isStandalone: true,
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: TechlifyListComponent,
+	decorators: [{ type: Directive }],
+	ctorParameters: () => [{
+		type: TechlifyService,
+		decorators: [{ type: Optional }]
+	}]
+});
+function techlifyListContract(options) {
+	const routeFilterIt = options.patchesFiltersFromRoute === false ? (() => void 0) : it;
+	describe("TechlifyListComponent Contract", () => {
+		it("should pass a service to the base class", () => {
+			const component = options.getComponent();
+			expect(component.service).toBe(options.getService());
+		});
+		it("should have a filter form", () => {
+			const component = options.getComponent();
+			expect(component.filterForm).toBeTruthy();
+		});
+		it("should call loadData on init", () => {
+			const component = options.getComponent();
+			spyOn(component, "loadData");
+			component.ngOnInit();
+			expect(component.loadData).toHaveBeenCalled();
+		});
+		routeFilterIt("should patch filters from route on init", () => {
+			const component = options.getComponent();
+			spyOn(component, "patchFiltersFromRoute");
+			component.ngOnInit();
+			expect(component.patchFiltersFromRoute).toHaveBeenCalled();
+		});
+		it("should reload when filter changes", fakeAsync(() => {
+			const component = options.getComponent();
+			const filterField = options.filterField ?? "search";
+			if (!component.filterForm?.get(filterField)) {
+				pending(`Filter '${filterField}' does not exist.`);
+				return;
+			}
+			spyOn(component, "reload");
+			component.listenFilterChanges();
+			component.filterForm.get(filterField)?.setValue("abc");
+			tick(501);
+			expect(component.reload).toHaveBeenCalled();
+		}));
+		it("should load next page on scroll", () => {
+			const component = options.getComponent();
+			component.page = 1;
+			component.lastPage = 3;
+			component.isWorking = false;
+			spyOn(component, "loadData");
+			component.onScroll();
+			expect(component.page).toBe(2);
+			expect(component.loadData).toHaveBeenCalled();
+		});
+		it("should not load next page while already loading", () => {
+			const component = options.getComponent();
+			component.page = 1;
+			component.lastPage = 3;
+			component.isWorking = true;
+			spyOn(component, "loadData");
+			component.onScroll();
+			expect(component.loadData).not.toHaveBeenCalled();
+		});
+		it("should update sort_by filter", () => {
+			const component = options.getComponent();
+			const control = component.filterForm.get("sort_by");
+			if (!control) {
+				pending("No sort_by control.");
+				return;
+			}
+			spyOn(control, "setValue");
+			component.sortColumn({
+				active: "name",
+				direction: "asc"
+			});
+			expect(control.setValue).toHaveBeenCalledWith("name|ASC");
+		});
+	});
+}
+var TechlifyShowComponent = class TechlifyShowComponent {
+	get pageTitle() {}
+	constructor(service) {
+		this.service = service;
+		this.isWorking = false;
+		this.routeParamName = "id";
+		this.titleService = inject(Title, { optional: true });
+		this.environmentService = inject(EnvironmentService, { optional: true });
+		this.route = inject(ActivatedRoute, { optional: true });
+		const resolvedTitle = this.pageTitle && this.pageTitle.trim().length > 0 ? this.pageTitle : this.environmentService?.get().appTitle;
+		this.titleService?.setTitle(resolvedTitle);
+	}
+	listenRouteChanges() {
+		this.route?.paramMap.subscribe((params) => {
+			this.id = this.getIdFromRoute(params);
+			this.loadData();
+		});
+	}
+	getIdFromRoute(params) {
+		return (params ?? this.route?.snapshot?.paramMap)?.get(this.routeParamName) ?? null;
+	}
+	getShowParams() {
+		return {};
+	}
+	loadData() {
+		if (!this.service) throw new Error(`${this.constructor.name}: Service is required to load the data`);
+		if (!this.id) return;
+		this.loadSubscription?.unsubscribe();
+		this.isWorking = true;
+		this.loadSubscription = this.service.show(this.id, this.getShowParams()).pipe(finalize(() => this.isWorking = false)).subscribe((result) => {
+			this.model = result?.item;
+			this.modelLoaded(this.model);
+		});
+	}
+	reload() {
+		this.loadData();
+	}
+	modelLoaded(model) {}
+	modelUpdated(model) {
+		if (model) {
+			this.model = model;
+			this.modelLoaded(this.model);
+		}
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: TechlifyShowComponent,
+			deps: [{
+				token: TechlifyService,
+				optional: true
+			}],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			type: TechlifyShowComponent,
+			isStandalone: true,
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: TechlifyShowComponent,
+	decorators: [{ type: Directive }],
+	ctorParameters: () => [{
+		type: TechlifyService,
+		decorators: [{ type: Optional }]
+	}]
+});
+function techlifyShowContract(options) {
+	describe("TechlifyShowComponent Contract", () => {
+		it("should pass a service to the base class", () => {
+			const component = options.getComponent();
+			expect(component.service).toBe(options.getService());
+		});
+		it("should listen route changes on init", () => {
+			const component = options.getComponent();
+			spyOn(component, "listenRouteChanges");
+			component.ngOnInit();
+			expect(component.listenRouteChanges).toHaveBeenCalled();
+		});
+		it("should get id from route params", () => {
+			const component = options.getComponent();
+			const routeParamName = options.routeParamName ?? "id";
+			const params = convertToParamMap({ [routeParamName]: "5" });
+			expect(component.getIdFromRoute(params)).toBe("5");
+		});
+		it("should load the model using show", () => {
+			const component = options.getComponent();
+			options.getService().show.and.returnValue(of({ item: { id: 5 } }));
+			component.id = 5;
+			component.loadData();
+			expect(options.getService().show).toHaveBeenCalledWith(5, jasmine.anything());
+			expect(component.model).toEqual({ id: 5 });
+			expect(component.isWorking).toBeFalse();
+		});
+		it("should not load without an id", () => {
+			const component = options.getComponent();
+			options.getService().show.calls.reset();
+			component.id = null;
+			component.loadData();
+			expect(options.getService().show).not.toHaveBeenCalled();
+		});
+		it("should replace the model on modelUpdated", () => {
+			const component = options.getComponent();
+			component.modelUpdated({ id: 7 });
+			expect(component.model).toEqual({ id: 7 });
+		});
+	});
+}
+export { RequestHelperService as a, TechlifyFormComponent as c, TechlifyListComponent as i, TechlifyService as l, TechlifyShowComponent as n, parseLocalDate as o, techlifyListContract as r, techlifyFormContract as s, techlifyShowContract as t };
+
+//# sourceMappingURL=ngx-techlify-core-base-model-oCILHkdE.mjs.map