Urađena test aplikacija. Povezan front i back.

1 files changed, 406 insertions, 0 deletions

diff --git a/sandbox/testAppNevena/Front/node_modules/@angular-devkit/schematics/src/tree/host-tree.js b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/schematics/src/tree/host-tree.js
new file mode 100644
index 00000000..8cde1dfa
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/@angular-devkit/schematics/src/tree/host-tree.js
@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterHostTree = exports.HostCreateTree = exports.HostTree = exports.HostDirEntry = void 0;
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const exception_1 = require("../exception/exception");
+const delegate_1 = require("./delegate");
+const entry_1 = require("./entry");
+const interface_1 = require("./interface");
+const recorder_1 = require("./recorder");
+const scoped_1 = require("./scoped");
+let _uniqueId = 0;
+class HostDirEntry {
+    constructor(parent, path, _host, _tree) {
+        this.parent = parent;
+        this.path = path;
+        this._host = _host;
+        this._tree = _tree;
+    }
+    get subdirs() {
+        return this._host
+            .list(this.path)
+            .filter((fragment) => this._host.isDirectory((0, core_1.join)(this.path, fragment)));
+    }
+    get subfiles() {
+        return this._host
+            .list(this.path)
+            .filter((fragment) => this._host.isFile((0, core_1.join)(this.path, fragment)));
+    }
+    dir(name) {
+        return this._tree.getDir((0, core_1.join)(this.path, name));
+    }
+    file(name) {
+        return this._tree.get((0, core_1.join)(this.path, name));
+    }
+    visit(visitor) {
+        try {
+            this.getSubfilesRecursively().forEach((file) => visitor(file.path, file));
+        }
+        catch (e) {
+            if (e !== interface_1.FileVisitorCancelToken) {
+                throw e;
+            }
+        }
+    }
+    getSubfilesRecursively() {
+        function _recurse(entry) {
+            return entry.subdirs.reduce((files, subdir) => [...files, ..._recurse(entry.dir(subdir))], entry.subfiles.map((subfile) => entry.file(subfile)));
+        }
+        return _recurse(this);
+    }
+}
+exports.HostDirEntry = HostDirEntry;
+class HostTree {
+    constructor(_backend = new core_1.virtualFs.Empty()) {
+        this._backend = _backend;
+        this._id = --_uniqueId;
+        this._ancestry = new Set();
+        this._dirCache = new Map();
+        this._record = new core_1.virtualFs.CordHost(new core_1.virtualFs.SafeReadonlyHost(_backend));
+        this._recordSync = new core_1.virtualFs.SyncDelegateHost(this._record);
+    }
+    [interface_1.TreeSymbol]() {
+        return this;
+    }
+    static isHostTree(tree) {
+        if (tree instanceof HostTree) {
+            return true;
+        }
+        if (typeof tree === 'object' && typeof tree._ancestry === 'object') {
+            return true;
+        }
+        return false;
+    }
+    _normalizePath(path) {
+        return (0, core_1.normalize)('/' + path);
+    }
+    _willCreate(path) {
+        return this._record.willCreate(path);
+    }
+    _willOverwrite(path) {
+        return this._record.willOverwrite(path);
+    }
+    _willDelete(path) {
+        return this._record.willDelete(path);
+    }
+    _willRename(path) {
+        return this._record.willRename(path);
+    }
+    branch() {
+        const branchedTree = new HostTree(this._backend);
+        branchedTree._record = this._record.clone();
+        branchedTree._recordSync = new core_1.virtualFs.SyncDelegateHost(branchedTree._record);
+        branchedTree._ancestry = new Set(this._ancestry).add(this._id);
+        return branchedTree;
+    }
+    isAncestorOf(tree) {
+        if (tree instanceof HostTree) {
+            return tree._ancestry.has(this._id);
+        }
+        if (tree instanceof delegate_1.DelegateTree) {
+            return this.isAncestorOf(tree._other);
+        }
+        if (tree instanceof scoped_1.ScopedTree) {
+            return this.isAncestorOf(tree._base);
+        }
+        return false;
+    }
+    merge(other, strategy = interface_1.MergeStrategy.Default) {
+        if (other === this) {
+            // Merging with yourself? Tsk tsk. Nothing to do at least.
+            return;
+        }
+        if (this.isAncestorOf(other)) {
+            // Workaround for merging a branch back into one of its ancestors
+            // More complete branch point tracking is required to avoid
+            strategy |= interface_1.MergeStrategy.Overwrite;
+        }
+        const creationConflictAllowed = (strategy & interface_1.MergeStrategy.AllowCreationConflict) == interface_1.MergeStrategy.AllowCreationConflict;
+        const overwriteConflictAllowed = (strategy & interface_1.MergeStrategy.AllowOverwriteConflict) == interface_1.MergeStrategy.AllowOverwriteConflict;
+        const deleteConflictAllowed = (strategy & interface_1.MergeStrategy.AllowDeleteConflict) == interface_1.MergeStrategy.AllowDeleteConflict;
+        other.actions.forEach((action) => {
+            switch (action.kind) {
+                case 'c': {
+                    const { path, content } = action;
+                    if (this._willCreate(path) || this._willOverwrite(path) || this.exists(path)) {
+                        const existingContent = this.read(path);
+                        if (existingContent && content.equals(existingContent)) {
+                            // Identical outcome; no action required
+                            return;
+                        }
+                        if (!creationConflictAllowed) {
+                            throw new exception_1.MergeConflictException(path);
+                        }
+                        this._record.overwrite(path, content).subscribe();
+                    }
+                    else {
+                        this._record.create(path, content).subscribe();
+                    }
+                    return;
+                }
+                case 'o': {
+                    const { path, content } = action;
+                    if (this._willDelete(path) && !overwriteConflictAllowed) {
+                        throw new exception_1.MergeConflictException(path);
+                    }
+                    // Ignore if content is the same (considered the same change).
+                    if (this._willOverwrite(path)) {
+                        const existingContent = this.read(path);
+                        if (existingContent && content.equals(existingContent)) {
+                            // Identical outcome; no action required
+                            return;
+                        }
+                        if (!overwriteConflictAllowed) {
+                            throw new exception_1.MergeConflictException(path);
+                        }
+                    }
+                    // We use write here as merge validation has already been done, and we want to let
+                    // the CordHost do its job.
+                    this._record.write(path, content).subscribe();
+                    return;
+                }
+                case 'r': {
+                    const { path, to } = action;
+                    if (this._willDelete(path)) {
+                        throw new exception_1.MergeConflictException(path);
+                    }
+                    if (this._willRename(path)) {
+                        if (this._record.willRenameTo(path, to)) {
+                            // Identical outcome; no action required
+                            return;
+                        }
+                        // No override possible for renaming.
+                        throw new exception_1.MergeConflictException(path);
+                    }
+                    this.rename(path, to);
+                    return;
+                }
+                case 'd': {
+                    const { path } = action;
+                    if (this._willDelete(path)) {
+                        // TODO: This should technically check the content (e.g., hash on delete)
+                        // Identical outcome; no action required
+                        return;
+                    }
+                    if (!this.exists(path) && !deleteConflictAllowed) {
+                        throw new exception_1.MergeConflictException(path);
+                    }
+                    this._recordSync.delete(path);
+                    return;
+                }
+            }
+        });
+    }
+    get root() {
+        return this.getDir('/');
+    }
+    // Readonly.
+    read(path) {
+        const entry = this.get(path);
+        return entry ? entry.content : null;
+    }
+    exists(path) {
+        return this._recordSync.isFile(this._normalizePath(path));
+    }
+    get(path) {
+        const p = this._normalizePath(path);
+        if (this._recordSync.isDirectory(p)) {
+            throw new core_1.PathIsDirectoryException(p);
+        }
+        if (!this._recordSync.exists(p)) {
+            return null;
+        }
+        return new entry_1.LazyFileEntry(p, () => Buffer.from(this._recordSync.read(p)));
+    }
+    getDir(path) {
+        const p = this._normalizePath(path);
+        if (this._recordSync.isFile(p)) {
+            throw new core_1.PathIsFileException(p);
+        }
+        let maybeCache = this._dirCache.get(p);
+        if (!maybeCache) {
+            let parent = (0, core_1.dirname)(p);
+            if (p === parent) {
+                parent = null;
+            }
+            maybeCache = new HostDirEntry(parent && this.getDir(parent), p, this._recordSync, this);
+            this._dirCache.set(p, maybeCache);
+        }
+        return maybeCache;
+    }
+    visit(visitor) {
+        this.root.visit((path, entry) => {
+            visitor(path, entry);
+        });
+    }
+    // Change content of host files.
+    overwrite(path, content) {
+        const p = this._normalizePath(path);
+        if (!this._recordSync.exists(p)) {
+            throw new exception_1.FileDoesNotExistException(p);
+        }
+        const c = typeof content == 'string' ? Buffer.from(content) : content;
+        this._record.overwrite(p, c).subscribe();
+    }
+    beginUpdate(path) {
+        const entry = this.get(path);
+        if (!entry) {
+            throw new exception_1.FileDoesNotExistException(path);
+        }
+        return recorder_1.UpdateRecorderBase.createFromFileEntry(entry);
+    }
+    commitUpdate(record) {
+        if (record instanceof recorder_1.UpdateRecorderBase) {
+            const path = record.path;
+            const entry = this.get(path);
+            if (!entry) {
+                throw new exception_1.ContentHasMutatedException(path);
+            }
+            else {
+                const newContent = record.apply(entry.content);
+                if (!newContent.equals(entry.content)) {
+                    this.overwrite(path, newContent);
+                }
+            }
+        }
+        else {
+            throw new exception_1.InvalidUpdateRecordException();
+        }
+    }
+    // Structural methods.
+    create(path, content) {
+        const p = this._normalizePath(path);
+        if (this._recordSync.exists(p)) {
+            throw new exception_1.FileAlreadyExistException(p);
+        }
+        const c = typeof content == 'string' ? Buffer.from(content) : content;
+        this._record.create(p, c).subscribe();
+    }
+    delete(path) {
+        this._recordSync.delete(this._normalizePath(path));
+    }
+    rename(from, to) {
+        this._recordSync.rename(this._normalizePath(from), this._normalizePath(to));
+    }
+    apply(action, strategy) {
+        throw new exception_1.SchematicsException('Apply not implemented on host trees.');
+    }
+    *generateActions() {
+        for (const record of this._record.records()) {
+            switch (record.kind) {
+                case 'create':
+                    yield {
+                        id: this._id,
+                        parent: 0,
+                        kind: 'c',
+                        path: record.path,
+                        content: Buffer.from(record.content),
+                    };
+                    break;
+                case 'overwrite':
+                    yield {
+                        id: this._id,
+                        parent: 0,
+                        kind: 'o',
+                        path: record.path,
+                        content: Buffer.from(record.content),
+                    };
+                    break;
+                case 'rename':
+                    yield {
+                        id: this._id,
+                        parent: 0,
+                        kind: 'r',
+                        path: record.from,
+                        to: record.to,
+                    };
+                    break;
+                case 'delete':
+                    yield {
+                        id: this._id,
+                        parent: 0,
+                        kind: 'd',
+                        path: record.path,
+                    };
+                    break;
+            }
+        }
+    }
+    get actions() {
+        // Create a list of all records until we hit our original backend. This is to support branches
+        // that diverge from each others.
+        return Array.from(this.generateActions());
+    }
+}
+exports.HostTree = HostTree;
+class HostCreateTree extends HostTree {
+    constructor(host) {
+        super();
+        const tempHost = new HostTree(host);
+        tempHost.visit((path) => {
+            const content = tempHost.read(path);
+            if (content) {
+                this.create(path, content);
+            }
+        });
+    }
+}
+exports.HostCreateTree = HostCreateTree;
+class FilterHostTree extends HostTree {
+    constructor(tree, filter = () => true) {
+        const newBackend = new core_1.virtualFs.SimpleMemoryHost();
+        // cast to allow access
+        const originalBackend = tree._backend;
+        const recurse = (base) => {
+            return originalBackend.list(base).pipe((0, operators_1.mergeMap)((x) => x), (0, operators_1.map)((path) => (0, core_1.join)(base, path)), (0, operators_1.concatMap)((path) => {
+                let isDirectory = false;
+                originalBackend.isDirectory(path).subscribe((val) => (isDirectory = val));
+                if (isDirectory) {
+                    return recurse(path);
+                }
+                let isFile = false;
+                originalBackend.isFile(path).subscribe((val) => (isFile = val));
+                if (!isFile || !filter(path)) {
+                    return rxjs_1.EMPTY;
+                }
+                let content = null;
+                originalBackend.read(path).subscribe((val) => (content = val));
+                if (!content) {
+                    return rxjs_1.EMPTY;
+                }
+                return newBackend.write(path, content);
+            }));
+        };
+        recurse((0, core_1.normalize)('/')).subscribe();
+        super(newBackend);
+        for (const action of tree.actions) {
+            if (!filter(action.path)) {
+                continue;
+            }
+            switch (action.kind) {
+                case 'c':
+                    this.create(action.path, action.content);
+                    break;
+                case 'd':
+                    this.delete(action.path);
+                    break;
+                case 'o':
+                    this.overwrite(action.path, action.content);
+                    break;
+                case 'r':
+                    this.rename(action.path, action.to);
+                    break;
+            }
+        }
+    }
+}
+exports.FilterHostTree = FilterHostTree;